feat: added buffer object, reworked objects with internal worker

src/server/state.rs

@@ -1,6 +1,7 @@
 
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::{mpsc, watch};
+use tracing::error;
 
 use crate::workspace::Workspace;
 
@@ -13,49 +14,52 @@ pub enum AlterState {
 	REMOVE { key: String },
 }
 
+#[derive(Debug)]
 pub struct StateManager {
-	store: HashMap<String, Arc<Workspace>>,
+	pub workspaces: watch::Receiver<HashMap<String, Arc<Workspace>>>,
-	rx:  mpsc::Receiver<AlterState>,
+	pub op_tx: mpsc::Sender<AlterState>, // TODO make method for this
-	tx: watch::Sender<HashMap<String, Arc<Workspace>>>
+	run: watch::Sender<bool>,
+}
+
+impl Drop for StateManager {
+	fn drop(&mut self) {
+		self.run.send(false).unwrap_or_else(|e| {
+			error!("Could not stop StateManager worker: {:?}", e);
+		})
+	}
 }
 
 impl StateManager {
-	pub fn new(rx: mpsc::Receiver<AlterState>, tx: watch::Sender<HashMap<String, Arc<Workspace>>>) -> StateManager {
+	pub fn new() -> Self {
-		StateManager { 
+		let (tx, mut rx) = mpsc::channel(32); // TODO quantify backpressure
-			store: HashMap::new(),
+		let (watch_tx, watch_rx) = watch::channel(HashMap::new());
-			rx,
+		let (stop_tx, stop_rx) = watch::channel(true);
-			tx
-		}
-	}
 
-	pub async fn run(mut self) {
+		let s = StateManager { 
-		loop {
+			workspaces: watch_rx,
-			if let Some(event) = self.rx.recv().await {
+			op_tx: tx,
+			run: stop_tx,
+		};
+
+		tokio::spawn(async move {
+			let mut store = HashMap::new();
+			while stop_rx.borrow().to_owned() {
+				if let Some(event) = rx.recv().await {
 					match event {
 						AlterState::ADD { key, w } => {
-						self.store.insert(key, Arc::new(w)); // TODO put in hashmap
+							store.insert(key, Arc::new(w)); // TODO put in hashmap
 						},
 						AlterState::REMOVE { key } => {
-						self.store.remove(&key);
+							store.remove(&key);
 						},
 					}
-				self.tx.send(self.store.clone()).unwrap();
+					watch_tx.send(store.clone()).unwrap();
 				} else {
 					break
 				}
 			}
-	}
-}
-
-
-pub fn run_state_manager() -> (mpsc::Sender<AlterState>, watch::Receiver<HashMap<String, Arc<Workspace>>>) {
-	let (tx, rx) = mpsc::channel(32); // TODO quantify backpressure
-	let (watch_tx, watch_rx) = watch::channel(HashMap::new());
-	let state = StateManager::new(rx, watch_tx);
-
-	let _task = tokio::spawn(async move {
-		state.run().await;
 		});
 
-	return (tx, watch_rx);
+		return s;
+	}
 }

src/server/workspace.rs

@@ -1,7 +1,69 @@
-use std::sync::Arc;
+use std::collections::HashMap;
 
 use operational_transform::OperationSeq;
-use tokio::sync::{broadcast, mpsc};
+use tokio::sync::{broadcast, mpsc, watch};
+use tracing::error;
+
+#[derive(Debug, Clone)]
+pub struct BufferView {
+	pub name: String,
+	pub content: watch::Receiver<String>,
+	op_tx: mpsc::Sender<OperationSeq>,
+}
+
+impl BufferView {
+	pub async fn op(&self, op: OperationSeq) -> Result<(), mpsc::error::SendError<OperationSeq>> {
+		self.op_tx.send(op).await
+	}
+}
+
+#[derive(Debug)]
+pub struct Buffer {
+	view: BufferView,
+	run: watch::Sender<bool>,
+}
+
+impl Drop for Buffer {
+	fn drop(&mut self) {
+		self.run.send(false).unwrap_or_else(|e| {
+			error!("Could not stop Buffer worker task: {:?}", e);
+		});
+	}
+}
+
+impl Buffer {
+	pub fn new(name: String, bus: broadcast::Sender<(String, OperationSeq)>) -> Self {
+		let (op_tx, mut op_rx) = mpsc::channel(32);
+		let (stop_tx, stop_rx) = watch::channel(true);
+		let (content_tx, content_rx) = watch::channel(String::new());
+
+		let b = Buffer {
+			run: stop_tx,
+			view: BufferView {
+				name: name.clone(),
+				op_tx,
+				content: content_rx,
+			},
+		};
+
+		tokio::spawn(async move {
+			let mut content = String::new();
+			while stop_rx.borrow().to_owned() {
+				// TODO handle these errors!!
+				let op = op_rx.recv().await.unwrap();
+				content = op.apply(content.as_str()).unwrap();
+				bus.send((name.clone(), op)).unwrap(); // TODO fails when there are no receivers subscribed
+				content_tx.send(content.clone()).unwrap();
+			}
+		});
+
+		return b;
+	}
+
+	pub fn view(&self) -> BufferView {
+		return self.view.clone();
+	}
+}
 
 pub struct WorkspaceView {
 	pub rx: broadcast::Receiver<OperationSeq>,
@@ -12,47 +74,59 @@ pub struct WorkspaceView {
 #[derive(Debug)]
 pub struct Workspace {
 	pub name: String,
-	pub content: String,
+	pub buffers: watch::Receiver<HashMap<String, BufferView>>,
-	pub tx: mpsc::Sender<OperationSeq>,
+	pub bus: broadcast::Sender<(String, OperationSeq)>,
-	w_tx: Arc<broadcast::Sender<OperationSeq>>,
+	op_tx: mpsc::Sender<BufferAction>,
+	run: watch::Sender<bool>,
 }
 
 impl Workspace {
-	pub fn new(
+	pub fn new(name: String) -> Self {
-		name: String,
+		let (op_tx, mut op_rx) = mpsc::channel(32);
-		content: String,
+		let (stop_tx, stop_rx) = watch::channel(true);
-		tx: mpsc::Sender<OperationSeq>,
+		let (buf_tx, buf_rx) = watch::channel(HashMap::new());
-		w_tx: Arc<broadcast::Sender<OperationSeq>>,
+		let (broadcast_tx, broadcast_rx) = broadcast::channel(32);
-	) -> Self {
+
-		Workspace {
+		let w = Workspace {
 			name,
-			content,
+			run: stop_tx,
-			tx,
+			op_tx,
-			w_tx,
+			buffers: buf_rx,
+			bus: broadcast_tx,
+		};
+
+		tokio::spawn(async move {
+			let mut buffers = HashMap::new();
+			while stop_rx.borrow().to_owned() {
+				// TODO handle these errors!!
+				let action = op_rx.recv().await.unwrap();
+				match action {
+					BufferAction::ADD { buffer } => {
+						buffers.insert(buffer.view.name.clone(), buffer);
+					}
+					BufferAction::REMOVE { name } => {
+						buffers.remove(&name);
+					}
+				}
+				buf_tx.send(
+					buffers.iter()
+						.map(|(k, v)| (k.clone(), v.view()))
+						.collect()
+				).unwrap();
+			}
+		});
+
+		return w;
 	}
 }
 
-	pub fn view(&self) -> WorkspaceView {
+pub enum BufferAction {
-		WorkspaceView {
+	ADD {
-			rx: self.w_tx.subscribe(),
+		buffer: Buffer,
-			tx: self.tx.clone(),
+	},
-		}
+	REMOVE {
-	}
+		name: String, // TODO remove by id?
-}
+	},
-
-pub async fn worker(
-	mut w: Workspace,
-	tx: Arc<broadcast::Sender<OperationSeq>>,
-	mut rx: mpsc::Receiver<OperationSeq>,
-) {
-	loop {
-		if let Some(op) = rx.recv().await {
-			w.content = op.apply(&w.content).unwrap();
-			tx.send(op).unwrap();
-		} else {
-			break;
-		}
-	}
 }
 
 // impl Default for Workspace {