2022-07-21 10:40:43 +02:00
|
|
|
use std::{collections::HashMap, pin::Pin, sync::Arc};
|
2022-07-13 01:58:34 +02:00
|
|
|
|
2022-07-16 03:46:16 +02:00
|
|
|
use state::AlterState;
|
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-13 01:58:34 +02:00
|
|
|
use tokio::sync::{mpsc, watch};
|
2022-07-21 10:40:43 +02:00
|
|
|
use tokio_stream::{wrappers::ReceiverStream, 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;
|
|
|
|
//use futures::{Stream, StreamExt};
|
2022-07-13 01:58:34 +02:00
|
|
|
|
|
|
|
use crate::workspace::Workspace as WorkspaceInstance; // TODO fuck!
|
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>>;
|
|
|
|
|
|
|
|
pub struct BufferService {}
|
|
|
|
|
|
|
|
#[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> {
|
|
|
|
println!("EchoServer::bidirectional_streaming_echo");
|
|
|
|
|
|
|
|
let mut in_stream = req.into_inner();
|
|
|
|
let (tx_og, rx) = mpsc::channel(128);
|
|
|
|
|
|
|
|
// this spawn here is required if you want to handle connection error.
|
|
|
|
// If we just map `in_stream` and write it back as `out_stream` the `out_stream`
|
|
|
|
// will be drooped when connection error occurs and error will never be propagated
|
|
|
|
// to mapped version of `in_stream`.
|
|
|
|
let tx = tx_og.clone();
|
|
|
|
tokio::spawn(async move {
|
|
|
|
while let Some(result) = in_stream.next().await {
|
|
|
|
match result {
|
|
|
|
Ok(v) => tx
|
|
|
|
.send(Ok(Operation {
|
|
|
|
action: 1,
|
|
|
|
row: 0,
|
|
|
|
column: 0,
|
|
|
|
op_id: 0,
|
|
|
|
text: None,
|
|
|
|
}))
|
|
|
|
.await
|
|
|
|
.expect("working rx"),
|
|
|
|
Err(err) => {
|
|
|
|
// if let Some(io_err) = match_for_io_error(&err) {
|
|
|
|
// if io_err.kind() == ErrorKind::BrokenPipe {
|
|
|
|
// // here you can handle special case when client
|
|
|
|
// // disconnected in unexpected way
|
|
|
|
// eprintln!("\tclient disconnected: broken pipe");
|
|
|
|
// break;
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
eprintln!("Error receiving operation from client");
|
|
|
|
|
|
|
|
match tx.send(Err(err)).await {
|
|
|
|
Ok(_) => (),
|
|
|
|
Err(_err) => break, // response was droped
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
println!("\tstream ended");
|
|
|
|
});
|
|
|
|
|
|
|
|
// echo just write the same data that was received
|
|
|
|
let out_stream = ReceiverStream::new(rx);
|
|
|
|
|
|
|
|
Ok(Response::new(Box::pin(out_stream) as Self::AttachStream))
|
|
|
|
}
|
|
|
|
}
|
2022-07-10 23:47:14 +02:00
|
|
|
|
2022-07-13 01:58:34 +02:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct WorkspaceService {
|
|
|
|
tx: mpsc::Sender<AlterState>,
|
2022-07-21 10:40:43 +02:00
|
|
|
rx: watch::Receiver<HashMap<String, Arc<WorkspaceInstance>>>,
|
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> {
|
|
|
|
println!("Got a request: {:?}", request);
|
2022-07-13 01:58:34 +02:00
|
|
|
let r = request.into_inner();
|
|
|
|
|
2022-07-21 10:40:43 +02:00
|
|
|
// let w = WorkspaceInstance::new(r.session_key.clone(), r.content.unwrap_or("".to_string()));
|
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> {
|
|
|
|
println!("Got a request: {:?}", request);
|
|
|
|
let r = request.into_inner();
|
|
|
|
|
|
|
|
if let Some(w) = self.rx.borrow().get(&r.session_key) {
|
|
|
|
let reply = proto::SessionResponse {
|
|
|
|
session_key: r.session_key,
|
|
|
|
accepted: true,
|
|
|
|
content: Some(w.content.clone()),
|
|
|
|
hash: None,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Response::new(reply))
|
|
|
|
} 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> {
|
|
|
|
println!("Got a 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> {
|
|
|
|
println!("Got a request: {:?}", request);
|
|
|
|
let r = request.into_inner();
|
|
|
|
let mut removed = false;
|
|
|
|
|
|
|
|
if self.rx.borrow().get(&r.session_key).is_some() {
|
2022-07-21 10:40:43 +02:00
|
|
|
self.tx
|
|
|
|
.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>> {
|
|
|
|
let addr = "[::1]:50051".parse()?;
|
2022-07-13 01:58:34 +02:00
|
|
|
|
|
|
|
let (tx, rx) = state::run_state_manager();
|
|
|
|
let greeter = WorkspaceService { tx, rx };
|
2022-07-21 10:40:43 +02:00
|
|
|
let processor = BufferService {};
|
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-10 19:01:56 +02:00
|
|
|
|
2022-07-10 20:44:43 +02:00
|
|
|
Ok(())
|
2022-07-10 19:01:56 +02:00
|
|
|
}
|