Created sender objects

+ added StreamMessageSender trait
+ added SocketSender struct
+ added StreamMessageSender implementation
+added new function
+ added new network module to main

server/src/main.rs

@@ -2,8 +2,10 @@ pub mod client;
 pub mod client_manager;
 pub mod messages;
 pub mod network_manager;
+pub mod network;
 pub mod server;
 pub mod encryption;
+pub mod prelude;
 
 use std::io;
 

server/src/network/mod.rs

@@ -0,0 +1,62 @@
+use std::sync::Arc;
+use std::io::Write;
+use std::io::Error;
+
+use async_trait::async_trait;
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+use tokio::io::split;
+use tokio::sync::Mutex;
+use tokio::io::ReadHalf;
+use tokio::io::BufReader;
+use tokio::io::WriteHalf;
+use tokio::net::TcpStream;
+use tokio::io::AsyncWriteExt;
+use tokio::io::AsyncBufReadExt;
+
+use crate::prelude::StreamMessageSender;
+
+#[derive(Debug)]
+pub struct SocketSender {
+	stream_tx: Mutex<WriteHalf<tokio::net::TcpStream>>,
+	stream_rx: Mutex<BufReader<ReadHalf<tokio::net::TcpStream>>>,
+}
+
+impl SocketSender {
+	pub fn new(connection: TcpStream) -> Arc<Self> {
+		let (rd, wd) = split(connection);
+		let reader = BufReader::new(rd);
+
+		Arc::new(SocketSender {
+			stream_tx: Mutex::new(wd),
+			stream_rx: Mutex::new(reader),
+		})
+	}
+}
+
+#[async_trait]
+impl StreamMessageSender for SocketSender {
+	async fn send<TOutMessage: Serialize + Send>
+		(self: &Arc<Self>, message: TOutMessage) -> Result<(), Error>
+	{ 
+		let mut out_buffer: Vec<u8> = Vec::new();
+		let message_string = serde_json::to_string(&message)?;
+		writeln!(out_buffer, "{}", message_string)?;
+		let mut lock = self.stream_tx.lock().await;
+		lock.write_all(&out_buffer).await?;
+		lock.flush().await?;
+		Ok(())
+	}
+
+	async fn recv<'de, TInMessage: DeserializeOwned + Send>
+		(self: &Arc<Self>) -> Result<TInMessage, Error>
+	{ 
+		let mut in_buffer = String::new();
+		let mut lock = self.stream_rx.lock().await;
+		lock.read_line(&mut in_buffer).await?;
+		let message: TInMessage = serde_json::from_str(&in_buffer)
+			.expect("[StreamMessageSender:recv] deserialisation failed");
+
+		Ok(message)
+	}
+}

server/src/prelude.rs

@@ -2,11 +2,12 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 
-use serde::{Serialize,Deserialize};
+use serde::Serialize;
+use serde::de::DeserializeOwned;
 
 
 #[async_trait]
-trait Sender<'de, TMessage: Deserialize<'de> + Serialize>  {
-	async fn send(self: &Arc<Self>, message: TMessage) -> Result<(), std::io::Error>;
-	async fn recv(self: &Arc<Self>) -> Result<TMessage, std::io::Error>;
+pub trait StreamMessageSender {
+	async fn send<TOutMessage: Serialize + Send>(self: &Arc<Self>, message: TOutMessage) -> Result<(), std::io::Error>;
+	async fn recv<'de, TInMessage: DeserializeOwned + Send>(self: &Arc<Self>) -> Result<TInMessage, std::io::Error>;
 }