Managing child actors

[kodysharma]

I am a noob in rust lang right now.
Is this the right way of managing child actor ?

use std::time::Duration;

mod hello;
use ractor::{Actor, ActorProcessingErr, ActorRef, RpcReplyPort};
use tokio::task::JoinHandle;

#[tokio::main]
async fn main() {
    let (actor, actor_handle) =
        Actor::spawn(Some("Helloworld actor".to_string()),
                     MyFirstActor, (), )
            .await
            .expect("Something went wrong");

    for i in 0..10 {
        actor.cast(MyFirstActorMessage::PrintHelloWorld).unwrap()
    }

    let rusult = ractor::call_t!(actor, MyFirstActorMessage::HowManyHelloWorlds, 100).unwrap();

    println!("How many helloworlds: {}", rusult);

    tokio::time::sleep(Duration::from_secs(5)).await;
    actor.stop(None);
    actor_handle.await.expect("Something went wrong");
}

pub enum MyFirstActorMessage {
    PrintHelloWorld,
    HowManyHelloWorlds(RpcReplyPort<u16>),
}

pub struct MyFirstActor;
pub struct MyFirstActorState {
    count: u16,
    print_actor: (ActorRef<Print>, JoinHandle<()>),
}

#[async_trait::async_trait]
impl Actor for MyFirstActor {
    type Msg = MyFirstActorMessage;
    type State = MyFirstActorState;
    type Arguments = ();

    async fn pre_start(
        &self,
        myself: ActorRef<Self::Msg>,
        args: Self::Arguments,
    ) -> Result<Self::State, ActorProcessingErr> {
        let child = Actor::spawn_linked(Some("PrintActor".into()), PrintActor, (), myself.get_cell());
        let child = child.await.expect("Something went wrong");
        let state = MyFirstActorState {
            count: 0,
            print_actor: child,
        };
        Ok(state)
    }

    async fn post_start(&self, myself: ActorRef<Self::Msg>, state: &mut Self::State) -> Result<(), ActorProcessingErr> {
        println!("Post start");
        Ok(())
    }

    async fn post_stop(&self, myself: ActorRef<Self::Msg>, state: &mut Self::State) -> Result<(), ActorProcessingErr> {
        println!("Post stop");
        Ok(())
    }

    async fn handle(
        &self,
        myself: ActorRef<Self::Msg>,
        message: Self::Msg,
        state: &mut Self::State,
    ) -> Result<(), ActorProcessingErr> {
        match message {
            MyFirstActorMessage::PrintHelloWorld => {
                state.count += 10;
                state.print_actor.0.cast(Print { msg: "Hello".into() }).unwrap();
            }
            
            MyFirstActorMessage::HowManyHelloWorlds(reply) => {
                if reply.send(state.count).is_err() {
                    println!("Something went wrong");
                }
            }
        }
        Ok(())
    }
}
pub struct Print {
    msg: String,
}
pub struct PrintActor;

#[async_trait::async_trait]
impl Actor for PrintActor {
    type Msg = Print;
    type State = ();
    type Arguments = ();

    async fn pre_start(
        &self,
        myself: ActorRef<Self::Msg>,
        args: Self::Arguments,
    ) -> Result<Self::State, ActorProcessingErr> {
        Ok(())
    }

    async fn handle(
        &self,
        myself: ActorRef<Self::Msg>,
        message: Self::Msg,
        state: &mut Self::State,
    ) -> Result<(), ActorProcessingErr> {
        println!("Printed: {}", message.msg);
        Ok(())
    }
}

[slawlor]

Yes it looks correct for setting up the link. However you probably will want to customize the supervision flow by customizing the handle_supervisor_evt method on the supervising actor, in this case the MyFirstActor.

That will let your supervisor control what happens when the child starts, stops, or fails. This is how you can have the parent manage the child.

As it stands, the default behavior is to stop the parent when the child exits (graceful stop, or fail)

https://github.com/slawlor/ractor/blob/main/ractor/src/actor/mod.rs#L338C5-L352C6