Child Actor and Supervision

[kunjee17]

I have wrote a simple code to implement child actors. I am not sure I m going into a correct direction.

Here is the code and then I ll ask the question.

use kameo::{Actor, messages};
use kameo::actor::ActorRef;
use kameo::message::Message;

#[derive(Actor)]
struct Addition;

#[messages]
impl Addition {
    #[message]
    fn add(&mut self, initial : u32,  amount: u32) -> u32 {
        initial + amount

    }
}

#[derive(Actor)]
struct Subtraction;

#[messages]
impl Subtraction {
    #[message]
    fn subtract(&mut self, initial : u32, amount: u32) -> u32 {
        initial - amount
    }
}

#[derive(Actor)]
struct Counter {
    count: u32,
    addition: ActorRef<Addition>,
    subtraction: ActorRef<Subtraction>
}
enum Calculate {
    Add(u32),
    Subtract(u32)
}

#[messages]
impl Counter {
    #[message]
    async fn calc(&mut self, p: Calculate) {
        println!("Addition Actor Id: {}", self.addition.id());
        println!("Subtraction Actor Id: {}", self.subtraction.id());
        
        match p {
            Calculate::Add(amount) => self.count =  self.addition.send(Add { initial : self.count, amount }).await.unwrap(),
            Calculate::Subtract(amount) => self.count = self.subtraction.send(Subtract { initial : self.count, amount }).await.unwrap(),
        }
    }

    #[query]
    fn get_count(&self) -> u32 {
        self.count
    }
}

#[tokio::main]
async fn main() {
    let counter_ref = kameo::spawn(Counter {
        count: 0,
        addition: kameo::spawn(Addition),
        subtraction: kameo::spawn(Subtraction)
    });
    counter_ref.send(Calc {
        p : Calculate::Add(10)
    }).await.unwrap();
    counter_ref.send(Calc {
        p : Calculate::Subtract(5)
    }).await.unwrap();
    let count = counter_ref.query(GetCount).await.unwrap();
    println!("Count: {}", count);
    println!("Id of Actor: {}", counter_ref.id());
    counter_ref.stop_gracefully().unwrap();

    println!("Hello, world!");
}

Now, when I stop the counter_ref does it stop addition and substraction as well. Or do I have to do something else. Coming from Akka style of actor system I can't find anything that using actor to create child actors.

I did find link and unlink child. But do I need to handle it in addition or subtraction . I am basically trying to use actor as unit of work. So, I need to create whole actor tree. May be before hand or some way dynamically on need to do basis. That what I m trying to achieve here. I am in right direction or do I need to change something?

[tqwewe]

Hi @kunjee17

Now, when I stop the counter_ref does it stop addition and substraction as well. Or do I have to do something else.

When all instances of an ActorRef are dropped, then the actor will be stopped too. So in this case your Addition and Subtraction actors will be stopped when the Counter actor is stopped.

I did find link and unlink child. But do I need to handle it in addition or subtraction .

The link and unlink methods let you run code when an actor is stopped/dies.
Using your actors, you could make the Counter actor print a message when the addition or subtraction actors die using the on_start and on_link_died methods.

Here's what that might look like:

struct Counter { ... }

impl Actor for Counter {
    async fn on_start(&mut self, actor_ref: ActorRef<Self>) -> Result<(), BoxError> {
        self.addition.link_child(&actor_ref);
        self.subtraction.link_child(&actor_ref);
    }
    
    async fn on_link_died(
        &mut self,
        actor_ref: WeakActorRef<Self>,
        id: u64,
        reason: ActorStopReason
    ) -> Result<Option<ActorStopReason>, BoxError> {
        if id == self.addition.id() {
            println!("addition actor died!");
        } else if id == self.subtraction.id() {
            println!("subtraction actor died!");
        }
        
        // We can't function without the child actors, so lets stop this actor
        Ok(Some(ActorStopReason::Killed)) 
    }
}

So instead of using the #[derive(Actor)] macro, implementing it manually lets us write code to be executed when a linked actor dies. And we can ensure the other actors are linked by running code on_start.

[kunjee17]

Hey, Thanks @tqwewe . So, does that mean that I am on right direction. I just need to use proper impl instead of Macros where and when required?

[tqwewe]

Yep, macros are helpful for very simple actors, but if you want any kind of custom behaviour, it's best to implement manually.

Actually, in my own projects I've been not even using the macros provided by kameo despite it being more verbose