dotfiles/agent/src/services/mod.rs

use std::collections::HashMap;

use bytes::Bytes;
use thiserror::Error;

mod exec;
mod terminal;

#[derive(Debug, Error)]
enum ServiceError {
    #[error("received an invalid body format for a valid message")]
    BodyFormatError,
}

struct Service {
    terminals: HashMap<String, ()>,
}

impl Service {
    fn serve(&mut self, message: crate::messaging::Message) {
        match message.subject() {
            crate::messaging::Subject::OpenTerminal => {}
            crate::messaging::Subject::Exec => todo!(),
            crate::messaging::Subject::Health => todo!(),
        }
    }
}

async fn route_message(message: crate::messaging::Message) -> Result<(), ServiceError> {
    match message.subject() {
        crate::messaging::Subject::Health => {}
        crate::messaging::Subject::Exec => {
            let ctx = Ctx::with_body(message.body())?;
            let _ = self::exec::exec(ctx).await;
        }
        crate::messaging::Subject::OpenTerminal => {
            let ctx = Ctx::with_body(message.body())?;
            let _ = self::terminal::open_terminal(ctx).await;
        }
    }

    Ok(())
}

struct Ctx<T> {
    body: T,
    terminals: HashMap<String, (crate::pty::Pty, tokio::process::Child)>,
}

impl<T> Ctx<T>
where
    T: TryFrom<Bytes>,
{
    fn with_body(body: Bytes) -> Result<Self, ServiceError> {
        let body = body
            .try_into()
            .map_err(|_err| ServiceError::BodyFormatError)?;

        Ok(Self {
            body,
            terminals: HashMap::default(),
        })
    }
}

pub async fn init_services(client: crate::messaging::Client) -> anyhow::Result<()> {
    let mut recv = client.messages_channel().await?;

    tokio::spawn(async move {
        while let Some(msg) = recv.recv().await {
            // TODO: How do i handle this error?
            if let Err(err) = route_message(msg).await {
                tracing::warn!("{}", err);
            };
        }
    });

    Ok(())
}