[SPIKE] Explore possible advancements of the Service framework

[iambriccardo]

No description provided.

[iambriccardo]

I took a first step at the implementation by completely rewriting the service with cleaner boundaries and a much simpler interface but realized that our services are not behaving as simple actors since they not only receive messages but also subscribe to several data sources. This made my decision not suitable for our use cases.

This is an example counter implemented with the new (discarded) service abstraction:

#[derive(Debug)]
pub enum CounterRequest {
    Increment,
    GetCount,
}

impl MessageRequest for CounterRequest {}

#[derive(Debug)]
pub enum CounterResponse {
    Count(u64),
}

impl MessageResponse for CounterResponse {}

#[derive(Debug)]
pub struct InnerCounterState {
    count: u64,
}

#[derive(Debug, Clone)]
pub struct CounterState(Arc<RwLock<InnerCounterState>>);

impl State for CounterState {
    type Public = CounterState;

    type Private = CounterState;

    fn split(self) -> (Self::Public, Self::Private) {
        (self.clone(), self)
    }
}

pub struct CounterService {}

impl CounterService {
    pub fn new() -> Self {
        Self {}
    }
}

impl ServiceNew for CounterService {
    type MessageRequest = CounterRequest;

    type MessageResponse = CounterResponse;

    type State = CounterState;

    fn initialize_state(self) -> Self::State {
        CounterState(Arc::new(RwLock::new(InnerCounterState { count: 0 })))
    }

    async fn handle(
        state: &mut CounterState,
        message: InnerMessage<Self::MessageRequest>,
    ) -> Result<Option<Self::MessageResponse>, HandlingError> {
        match message {
            InnerMessage::User(message) => match message {
                CounterRequest::Increment => {
                    state.0.write().await.count += 1;
                    Ok(None)
                }
                CounterRequest::GetCount => {
                    Ok(Some(CounterResponse::Count(state.0.read().await.count)))
                }
            },
            InnerMessage::System(message) => {
                match message {
                    SystemMessage::Shutdown(timeout) => {
                        // TODO: handle shutdown.
                    }
                }

                Ok(None)
            }
        }
    }
}

I iterated other versions with more improvements but decided to resort to solving individual problems in our implementation rather than rewriting it.