How to create "generic" Worker

[killix]

I'm currently working on a project where I'm using the Apalis Rust library to handle asynchronous tasks and workers. Specifically, I'm trying to define a system where I can register and manage generic workers of type T. I've written a proof-of-concept (POC) to illustrate what I'm trying to achieve, but I'm encountering issues with the definition of workers (Vec<Worker<Ready<S, P>>>)

use apalis::prelude::*;
use apalis::redis::RedisStorage;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::error::Error;
use std::fmt::Debug;
use std::sync::Arc;
use tower::Service;
use crate::error::{AppError, Result};

#[async_trait::async_trait]
pub trait BasicTrait:
    Clone + std::marker::Unpin + std::marker::Send + std::marker::Sync + Serialize + DeserializeOwned
{
    type Svc: Clone
        + std::marker::Unpin
        + std::marker::Send
        + std::marker::Sync
        + Serialize
        + DeserializeOwned;
    type Args: Job
        + Clone
        + std::marker::Unpin
        + std::marker::Send
        + std::marker::Sync
        + Serialize
        + DeserializeOwned;
    type Err: Error + Into<AppError>;

    async fn process(&self, job: Self::Args) -> Result<()>;

    fn name(&self) -> String;
}

pub async fn handle_task_0<T: BasicTrait + 'static>(job: <T as BasicTrait>::Args, svc: Data<Arc<T>>) {
    tracing::info!("Attempting to send email to");
    svc.process(job).await.unwrap();
}


pub struct Workers<
    T: BasicTrait + 'static,
    J: Send + Sync + 'static,
    S: Service<Request<J>> + Send + 'static + Clone,
    P: Backend<Request<J>> + 'static,
> {
    pub workers: Vec<Worker<Ready<S, P>>>,
    pub storage: RedisStorage<T::Args>,
    j: std::marker::PhantomData<J>,
}

impl<
T: BasicTrait + 'static,
J: Send + Sync + 'static,
S: Service<Request<J>> + Send + 'static + Clone,
P: Backend<Request<J>> + 'static,
> Workers<T, J, S, P> {
    pub fn new(storage: RedisStorage<T::Args>) -> Self {
        Self {
            workers: vec![],
            storage,
            j: std::marker::PhantomData,
        }
    }

    pub fn add_worker(&mut self, svc: T) {
        let worker = WorkerBuilder::new("worker")
            .data(Arc::new(svc)) // Add the data in shared state
            .with_storage(self.storage.clone())
            .build_fn(handle_task_0::<T>); // Generic handler over the model

        self.workers.push(worker);
    }
}

I'm open to any suggestions or alternative approaches to achieving my goal of defining and managing generic workers.
Thanks!

[geofmureithi]

Will all workers be of the same type? I am guessing not. Then you have to use dyn and concrete types such as BoxCloneService. Monitor already allows the registration of unassosiated workers so you should check that first.

[killix]

Thanks I will check.