2023-08-20 00:46:55 +02:00
|
|
|
//! ### client
|
2024-01-25 02:13:45 +01:00
|
|
|
//!
|
2023-08-20 00:46:55 +02:00
|
|
|
//! codemp client manager, containing grpc services
|
|
|
|
|
2024-01-25 03:25:45 +01:00
|
|
|
use std::collections::BTreeMap;
|
2024-01-25 02:13:45 +01:00
|
|
|
use std::sync::Arc;
|
|
|
|
use tokio::sync::mpsc;
|
|
|
|
use tonic::service::interceptor::InterceptedService;
|
|
|
|
use tonic::service::Interceptor;
|
|
|
|
use tonic::transport::{Channel, Endpoint};
|
|
|
|
use uuid::Uuid;
|
|
|
|
|
|
|
|
use crate::api::controller::ControllerWorker;
|
|
|
|
use crate::cursor::worker::CursorWorker;
|
|
|
|
use crate::proto::buffer_service::buffer_client::BufferClient;
|
|
|
|
use crate::proto::cursor_service::cursor_client::CursorClient;
|
|
|
|
use crate::proto::workspace::{JoinRequest, Token};
|
|
|
|
use crate::proto::workspace_service::workspace_client::WorkspaceClient;
|
|
|
|
use crate::workspace::Workspace;
|
2023-08-16 23:09:47 +02:00
|
|
|
|
2023-08-20 00:46:55 +02:00
|
|
|
/// codemp client manager
|
|
|
|
///
|
|
|
|
/// contains all required grpc services and the unique user id
|
|
|
|
/// will disconnect when dropped
|
|
|
|
/// can be used to interact with server
|
2023-08-17 02:58:55 +02:00
|
|
|
pub struct Client {
|
2024-01-25 02:13:45 +01:00
|
|
|
user_id: Uuid,
|
|
|
|
token_tx: Arc<tokio::sync::watch::Sender<Token>>,
|
2024-01-25 03:25:45 +01:00
|
|
|
pub workspaces: BTreeMap<String, Workspace>,
|
2024-01-25 02:13:45 +01:00
|
|
|
services: Arc<Services>
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub(crate) struct ClientInterceptor {
|
|
|
|
token: tokio::sync::watch::Receiver<Token>
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
impl Interceptor for ClientInterceptor {
|
|
|
|
fn call(&mut self, mut request: tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status> {
|
|
|
|
if let Ok(token) = self.token.borrow().token.parse() {
|
|
|
|
request.metadata_mut().insert("auth", token);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(request)
|
|
|
|
}
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
pub(crate) struct Services {
|
|
|
|
pub(crate) workspace: crate::proto::workspace_service::workspace_client::WorkspaceClient<InterceptedService<Channel, ClientInterceptor>>,
|
|
|
|
pub(crate) buffer: crate::proto::buffer_service::buffer_client::BufferClient<InterceptedService<Channel, ClientInterceptor>>,
|
|
|
|
pub(crate) cursor: crate::proto::cursor_service::cursor_client::CursorClient<InterceptedService<Channel, ClientInterceptor>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO meno losco
|
|
|
|
fn parse_codemp_connection_string<'a>(string: &'a str) -> (String, String) {
|
|
|
|
let url = string.replace("codemp://", "");
|
|
|
|
let (host, workspace) = url.split_once('/').unwrap();
|
|
|
|
(format!("http://{}", host), workspace.to_string())
|
|
|
|
}
|
|
|
|
|
2023-08-17 02:58:55 +02:00
|
|
|
impl Client {
|
2023-08-20 00:46:55 +02:00
|
|
|
/// instantiate and connect a new client
|
2024-01-25 02:13:45 +01:00
|
|
|
pub async fn new(dest: &str) -> crate::Result<Self> { //TODO interceptor
|
|
|
|
let (_host, _workspace_id) = parse_codemp_connection_string(dest);
|
2023-08-16 23:09:47 +02:00
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
let channel = Endpoint::from_shared(dest.to_string())?
|
|
|
|
.connect()
|
|
|
|
.await?;
|
2023-08-16 23:09:47 +02:00
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
let (token_tx, token_rx) = tokio::sync::watch::channel(
|
|
|
|
Token { token: "".to_string() }
|
|
|
|
);
|
2023-08-19 04:02:21 +02:00
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
let inter = ClientInterceptor { token: token_rx };
|
|
|
|
|
|
|
|
let buffer = BufferClient::with_interceptor(channel.clone(), inter.clone());
|
|
|
|
let cursor = CursorClient::with_interceptor(channel.clone(), inter.clone());
|
|
|
|
let workspace = WorkspaceClient::with_interceptor(channel.clone(), inter.clone());
|
|
|
|
|
|
|
|
let user_id = uuid::Uuid::new_v4();
|
2023-08-19 04:02:21 +02:00
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
Ok(Client {
|
|
|
|
user_id,
|
|
|
|
token_tx: Arc::new(token_tx),
|
2024-01-25 03:25:45 +01:00
|
|
|
workspaces: BTreeMap::new(),
|
2024-01-25 02:13:45 +01:00
|
|
|
services: Arc::new(Services { workspace, buffer, cursor })
|
|
|
|
})
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|
|
|
|
|
2023-08-20 00:46:55 +02:00
|
|
|
/// join a workspace, starting a cursorcontroller and returning a new reference to it
|
2024-01-25 02:13:45 +01:00
|
|
|
///
|
2023-09-03 23:04:08 +02:00
|
|
|
/// to interact with such workspace [crate::api::Controller::send] cursor events or
|
|
|
|
/// [crate::api::Controller::recv] for events on the associated [crate::cursor::Controller].
|
2024-01-25 02:13:45 +01:00
|
|
|
pub async fn join(&mut self, workspace_id: &str) -> crate::Result<()> {
|
|
|
|
self.token_tx.send(self.services.workspace.clone().join(
|
|
|
|
tonic::Request::new(JoinRequest { username: "".to_string(), password: "".to_string() }) //TODO
|
|
|
|
).await?.into_inner())?;
|
|
|
|
|
|
|
|
let (tx, rx) = mpsc::channel(10);
|
|
|
|
let stream = self.services.cursor.clone()
|
|
|
|
.attach(tokio_stream::wrappers::ReceiverStream::new(rx))
|
|
|
|
.await?
|
|
|
|
.into_inner();
|
|
|
|
|
|
|
|
let worker = CursorWorker::new(self.user_id.clone());
|
|
|
|
let controller = Arc::new(worker.subscribe());
|
2023-08-16 23:09:47 +02:00
|
|
|
tokio::spawn(async move {
|
2024-01-25 02:13:45 +01:00
|
|
|
tracing::debug!("controller worker started");
|
|
|
|
worker.work(tx, stream).await;
|
|
|
|
tracing::debug!("controller worker stopped");
|
2023-08-16 23:09:47 +02:00
|
|
|
});
|
|
|
|
|
2024-01-25 03:25:45 +01:00
|
|
|
self.workspaces.insert(workspace_id.to_string(), Workspace::new(
|
2024-01-25 02:13:45 +01:00
|
|
|
workspace_id.to_string(),
|
|
|
|
self.user_id,
|
|
|
|
self.token_tx.clone(),
|
|
|
|
controller,
|
|
|
|
self.services.clone()
|
|
|
|
).await?);
|
2023-08-16 23:09:47 +02:00
|
|
|
|
2024-01-25 02:13:45 +01:00
|
|
|
Ok(())
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|
2024-01-25 03:25:45 +01:00
|
|
|
|
|
|
|
pub fn user_id(&self) -> Uuid {
|
|
|
|
self.user_id.clone()
|
|
|
|
}
|
2023-08-16 23:09:47 +02:00
|
|
|
}
|