2022-07-30 03:02:38 +02:00
|
|
|
use std::collections::VecDeque;
|
|
|
|
use std::{pin::Pin, sync::Arc};
|
2022-07-13 01:58:34 +02:00
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
use tokio_stream::wrappers::ReceiverStream;
|
|
|
|
use tracing::{info, debug, warn, error};
|
|
|
|
|
|
|
|
use operational_transform::OperationSeq;
|
|
|
|
use state::{AlterState, StateManager};
|
2022-07-10 19:01:56 +02:00
|
|
|
use tonic::{transport::Server, Request, Response, Status};
|
|
|
|
|
2022-07-13 01:58:34 +02:00
|
|
|
pub mod proto {
|
|
|
|
tonic::include_proto!("workspace");
|
2022-07-21 10:40:43 +02:00
|
|
|
tonic::include_proto!("buffer");
|
2022-07-10 19:01:56 +02:00
|
|
|
}
|
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
use tokio::sync::{mpsc, broadcast};
|
|
|
|
use tokio_stream::{Stream, StreamExt}; // TODO example used this?
|
2022-07-13 01:58:34 +02:00
|
|
|
|
2022-07-21 10:40:43 +02:00
|
|
|
use proto::buffer_server::{Buffer, BufferServer};
|
2022-07-13 01:58:34 +02:00
|
|
|
use proto::workspace_server::{Workspace, WorkspaceServer};
|
2022-07-21 10:40:43 +02:00
|
|
|
use proto::{Operation, SessionRequest, SessionResponse};
|
|
|
|
|
|
|
|
use tonic::Streaming;
|
2022-07-30 03:02:38 +02:00
|
|
|
use workspace::BufferView;
|
2022-07-21 10:40:43 +02:00
|
|
|
//use futures::{Stream, StreamExt};
|
2022-07-13 01:58:34 +02:00
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
use crate::workspace::Workspace as WorkspaceInstance; // TODO fuck x2!
|
2022-07-10 23:47:14 +02:00
|
|
|
|
2022-07-13 01:58:34 +02:00
|
|
|
pub mod state;
|
2022-07-21 10:40:43 +02:00
|
|
|
pub mod workspace;
|
|
|
|
|
|
|
|
type OperationStream = Pin<Box<dyn Stream<Item = Result<Operation, Status>> + Send>>;
|
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
pub struct BufferService {
|
|
|
|
state: Arc<StateManager>,
|
|
|
|
}
|
|
|
|
|
|
|
|
fn op_seq(o: &Operation) -> OperationSeq { todo!() }
|
|
|
|
fn op_net(o: &OperationSeq) -> Operation { todo!() }
|
|
|
|
|
|
|
|
// async fn buffer_worker(tx: mpsc::Sender<Result<Operation, Status>>, mut rx:Streaming<Operation>, mut rx_core: mpsc::Receiver<Operation>) {
|
|
|
|
async fn buffer_worker(bv: BufferView, mut client_rx: Streaming<Operation>, tx_client:mpsc::Sender<Result<Operation, Status>>, mut rx_core:broadcast::Receiver<(String, OperationSeq)>) {
|
|
|
|
let mut queue : VecDeque<Operation> = VecDeque::new();
|
|
|
|
loop {
|
|
|
|
tokio::select! {
|
|
|
|
client_op = client_rx.next() => {
|
|
|
|
if let Some(result) = client_op {
|
|
|
|
match result {
|
|
|
|
Ok(op) => {
|
|
|
|
bv.op(op_seq(&op)).await.unwrap(); // TODO make OpSeq from network Operation pkt!
|
|
|
|
queue.push_back(op);
|
|
|
|
},
|
|
|
|
Err(status) => {
|
|
|
|
error!("error receiving op from client: {:?}", status);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
server_op = rx_core.recv() => {
|
|
|
|
if let Ok(oop) = server_op {
|
|
|
|
let mut send_op = true;
|
|
|
|
for (i, _op) in queue.iter().enumerate() {
|
|
|
|
if true { // TODO must compare underlying OperationSeq here! (op.equals(server_op))
|
|
|
|
queue.remove(i);
|
|
|
|
send_op = false;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
// serv_op.transform(op); // TODO transform OpSeq !
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if send_op {
|
|
|
|
tx_client.send(Ok(op_net(&oop.1))).await.unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-07-21 10:40:43 +02:00
|
|
|
|
|
|
|
#[tonic::async_trait]
|
|
|
|
impl Buffer for BufferService {
|
|
|
|
// type ServerStreamingEchoStream = ResponseStream;
|
|
|
|
type AttachStream = OperationStream;
|
|
|
|
|
|
|
|
async fn attach(
|
|
|
|
&self,
|
|
|
|
req: Request<Streaming<Operation>>,
|
|
|
|
) -> Result<tonic::Response<OperationStream>, Status> {
|
2022-07-30 03:02:38 +02:00
|
|
|
let session_id : String;
|
|
|
|
if let Some(sid) = req.metadata().get("session_id") {
|
|
|
|
session_id = sid.to_str().unwrap().to_string();
|
|
|
|
} else {
|
|
|
|
return Err(Status::failed_precondition("Missing metadata key 'session_id'"));
|
|
|
|
}
|
|
|
|
|
|
|
|
let path : String;
|
|
|
|
if let Some(p) = req.metadata().get("path") {
|
|
|
|
path = p.to_str().unwrap().to_string();
|
|
|
|
} else {
|
|
|
|
return Err(Status::failed_precondition("Missing metadata key 'path'"));
|
|
|
|
}
|
|
|
|
// TODO make these above nicer? more concise? idk
|
2022-07-21 10:40:43 +02:00
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
if let Some(workspace) = self.state.workspaces.borrow().get(&session_id) {
|
|
|
|
let in_stream = req.into_inner();
|
|
|
|
let (tx_og, rx) = mpsc::channel::<Result<Operation, Status>>(128);
|
2022-07-21 10:40:43 +02:00
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
let b: BufferView = workspace.buffers.borrow().get(&path).unwrap().clone();
|
|
|
|
let w = workspace.clone();
|
|
|
|
tokio::spawn(async move { buffer_worker(b, in_stream, tx_og, w.bus.subscribe()).await; });
|
|
|
|
|
|
|
|
// echo just write the same data that was received
|
|
|
|
let out_stream = ReceiverStream::new(rx);
|
|
|
|
|
|
|
|
return Ok(Response::new(Box::pin(out_stream) as Self::AttachStream));
|
|
|
|
} else {
|
|
|
|
return Err(Status::not_found(format!("Norkspace with session_id {}", session_id)));
|
|
|
|
}
|
2022-07-21 10:40:43 +02:00
|
|
|
}
|
|
|
|
}
|
2022-07-10 23:47:14 +02:00
|
|
|
|
2022-07-13 01:58:34 +02:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct WorkspaceService {
|
2022-07-30 03:02:38 +02:00
|
|
|
state: Arc<StateManager>,
|
2022-07-13 01:58:34 +02:00
|
|
|
}
|
2022-07-10 20:44:43 +02:00
|
|
|
|
|
|
|
#[tonic::async_trait]
|
2022-07-13 01:58:34 +02:00
|
|
|
impl Workspace for WorkspaceService {
|
2022-07-10 20:44:43 +02:00
|
|
|
async fn create(
|
|
|
|
&self,
|
|
|
|
request: Request<SessionRequest>,
|
|
|
|
) -> Result<Response<SessionResponse>, Status> {
|
2022-07-30 03:02:38 +02:00
|
|
|
debug!("create request: {:?}", request);
|
2022-07-13 01:58:34 +02:00
|
|
|
let r = request.into_inner();
|
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
let w = WorkspaceInstance::new(r.session_key.clone());
|
2022-07-13 01:58:34 +02:00
|
|
|
|
|
|
|
let reply = proto::SessionResponse {
|
|
|
|
session_key: r.session_key.clone(),
|
|
|
|
accepted: true,
|
2022-07-21 10:40:43 +02:00
|
|
|
content: None, // Some(w.content.clone()),
|
2022-07-13 01:58:34 +02:00
|
|
|
hash: None,
|
|
|
|
};
|
|
|
|
|
2022-07-21 10:40:43 +02:00
|
|
|
// self.tx.send(AlterState::ADD{key: r.session_key.clone(), w}).await.unwrap();
|
2022-07-13 01:58:34 +02:00
|
|
|
|
|
|
|
Ok(Response::new(reply))
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn sync(
|
|
|
|
&self,
|
|
|
|
request: Request<SessionRequest>,
|
|
|
|
) -> Result<Response<SessionResponse>, Status> {
|
2022-07-30 03:02:38 +02:00
|
|
|
debug!("sync request: {:?}", request);
|
2022-07-13 01:58:34 +02:00
|
|
|
let r = request.into_inner();
|
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
if let Some(w) = self.state.workspaces.borrow().get(&r.session_key) {
|
|
|
|
if let Some(buf) = w.buffers.borrow().get(&r.session_key) {
|
|
|
|
let reply = proto::SessionResponse {
|
|
|
|
session_key: r.session_key,
|
|
|
|
accepted: true,
|
|
|
|
content: Some(buf.content.borrow().clone()),
|
|
|
|
hash: None,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Response::new(reply))
|
|
|
|
} else {
|
|
|
|
Err(Status::out_of_range("fuck you".to_string()))
|
|
|
|
}
|
2022-07-13 01:58:34 +02:00
|
|
|
} else {
|
|
|
|
Err(Status::out_of_range("fuck you".to_string()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO make it do something
|
|
|
|
async fn join(
|
|
|
|
&self,
|
|
|
|
request: Request<SessionRequest>,
|
|
|
|
) -> Result<Response<SessionResponse>, Status> {
|
2022-07-30 03:02:38 +02:00
|
|
|
debug!("join request: {:?}", request);
|
2022-07-10 20:44:43 +02:00
|
|
|
|
2022-07-13 01:58:34 +02:00
|
|
|
let reply = proto::SessionResponse {
|
|
|
|
session_key: request.into_inner().session_key,
|
|
|
|
accepted: true,
|
|
|
|
content: None,
|
|
|
|
hash: None,
|
2022-07-10 20:44:43 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Response::new(reply))
|
|
|
|
}
|
2022-07-13 01:58:34 +02:00
|
|
|
|
|
|
|
async fn leave(
|
|
|
|
&self,
|
|
|
|
request: Request<SessionRequest>,
|
|
|
|
) -> Result<Response<SessionResponse>, Status> {
|
2022-07-30 03:02:38 +02:00
|
|
|
debug!("leave request: {:?}", request);
|
2022-07-13 01:58:34 +02:00
|
|
|
let r = request.into_inner();
|
|
|
|
let mut removed = false;
|
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
if self.state.workspaces.borrow().get(&r.session_key).is_some() {
|
|
|
|
self.state.op_tx
|
2022-07-21 10:40:43 +02:00
|
|
|
.send(AlterState::REMOVE {
|
|
|
|
key: r.session_key.clone(),
|
|
|
|
})
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2022-07-13 01:58:34 +02:00
|
|
|
removed = true; // TODO this is a lie! Verify it
|
|
|
|
}
|
|
|
|
|
|
|
|
let reply = proto::SessionResponse {
|
|
|
|
session_key: r.session_key,
|
|
|
|
accepted: removed,
|
|
|
|
content: None,
|
|
|
|
hash: None,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Response::new(reply))
|
|
|
|
}
|
2022-07-10 20:44:43 +02:00
|
|
|
}
|
2022-07-10 19:01:56 +02:00
|
|
|
|
2022-07-10 20:44:43 +02:00
|
|
|
#[tokio::main]
|
|
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
2022-07-30 03:02:38 +02:00
|
|
|
tracing_subscriber::fmt::init();
|
|
|
|
|
2022-07-10 20:44:43 +02:00
|
|
|
let addr = "[::1]:50051".parse()?;
|
2022-07-13 01:58:34 +02:00
|
|
|
|
2022-07-30 03:02:38 +02:00
|
|
|
let state = Arc::new(StateManager::new());
|
|
|
|
|
|
|
|
let greeter = WorkspaceService { state: state.clone() };
|
|
|
|
let processor = BufferService { state: state.clone() };
|
|
|
|
|
|
|
|
info!("Starting server");
|
2022-07-10 19:01:56 +02:00
|
|
|
|
2022-07-10 20:44:43 +02:00
|
|
|
Server::builder()
|
2022-07-13 01:58:34 +02:00
|
|
|
.add_service(WorkspaceServer::new(greeter))
|
2022-07-21 10:40:43 +02:00
|
|
|
.add_service(BufferServer::new(processor))
|
2022-07-10 20:44:43 +02:00
|
|
|
.serve(addr)
|
|
|
|
.await?;
|
2022-07-30 03:02:38 +02:00
|
|
|
/*
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
// install global collector configured based on RUST_LOG env var.
|
|
|
|
tracing_subscriber::fmt::init();
|
|
|
|
|
|
|
|
let number_of_yaks = 3;
|
|
|
|
// this creates a new event, outside of any spans.
|
|
|
|
info!(number_of_yaks, "preparing to shave yaks");
|
|
|
|
|
|
|
|
let number_shaved = yak_shave::shave_all(number_of_yaks);
|
|
|
|
info!(
|
|
|
|
all_yaks_shaved = number_shaved == number_of_yaks,
|
|
|
|
"yak shaving completed."
|
|
|
|
);
|
|
|
|
}
|
|
|
|
*/
|
2022-07-10 19:01:56 +02:00
|
|
|
|
2022-07-10 20:44:43 +02:00
|
|
|
Ok(())
|
2022-07-10 19:01:56 +02:00
|
|
|
}
|