Handling failing workers on start in ActorPool

[ahassany]

The curent implementation of ActorPool assumes the factor always succeed in starting works. However, this is not always the case, for instance, if I'm starting workers that will listen on a certain UDP/TCP Port they might fail because of OS permissions. In the current implementation there's no way to tell if the works have started and how many are healthy, or away to terminate the pool if a min number of workers are not running.

Am I missing the point of the ActorPool, or people think there's a need to extend its API to be more robust to failures?

I put a simple test case to show the issue:

use kameo::{
    Actor,
    actor::ActorRef,
};
use kameo_actors::pool::ActorPool;

pub struct FailingActor;

#[derive(Debug, Clone)]
pub struct ActorError;

impl std::fmt::Display for ActorError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ActorError")
    }
}

impl std::error::Error for ActorError {}


impl Actor for FailingActor {
    type Error = ActorError;
    async fn on_start(&mut self, actor_ref: ActorRef<Self>) -> Result<(), Self::Error> {
        println!("Starting actor");
        Err(ActorError)
    }
}

#[tokio::test]
async fn test_actor_start() {
    let actor_ref = kameo::spawn(FailingActor);
    let result = actor_ref.wait_startup_result().await;
    // this is passing
    assert!(result.is_err());
}

#[tokio::test]
async fn test_pool_start() {
    let actor_ref = kameo::spawn(ActorPool::new(1, move || kameo::spawn(FailingActor)));
    let result = actor_ref.wait_startup_result().await;
    // this fails, since the pool is started but none of the workers is starting
    assert!(result.is_err());
}

[tqwewe]

This indeed seems like an issue. Would it be solved if the actor pool simply created a new worker when it detects on is down? It already does that, but since the errors in your example occur during on_start, it fails before its linked.

So perhaps when you send a message, and a worker is detected as not running, it can just start that worker back up?