Small refactoring

Author: idavydoff

client/Cargo.lock

@@ -7,6 +7,5 @@ edition = "2021"
 
 [dependencies]
 clap = { version = "4.1.1", features = ["derive"] }
-tokio = { version = "1", features = ["full"] }
 termion = "2.0.1"
 parking_lot = "0.12.1"

client/Cargo.toml

@@ -46,11 +46,12 @@ impl State {
 
   fn read_username(&mut self) -> io::Result<()> {
     println!("{}", termion::clear::All);
-    write!(std::io::stdout(), "Username: ")?;
+    print!("Username: ");
     std::io::stdout().flush()?;
-    let mut input = BufReader::new(std::io::stdin());
+
     let mut username = String::new();
-    input.read_line(&mut username)?;
+    io::stdin().read_line(&mut username)?;
+
     self.username = username.trim().to_owned();
     println!("{}", termion::clear::All);
 

client/src/state.rs

@@ -23,25 +23,6 @@ impl fmt::Display for ParseSignalDataError {
   }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AuthConnectionError;
-impl Error for AuthConnectionError {}
-impl fmt::Display for AuthConnectionError {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "auth connection error")
-  }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IncomingMessageError;
-impl Error for IncomingMessageError {}
-impl fmt::Display for IncomingMessageError {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "incoming message error")
-  }
-}
-
-
 #[derive(Debug, Clone, Copy)]
 pub enum SignalType {
   Connection,

client/src/types.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 
 use service::Service;
 use settings::Settings;
-use state::{State};
+use state::State;
 
 mod settings;
 mod state;
@@ -13,7 +13,7 @@ mod reader;
 
 fn main() -> Result<()> {
   let settings = Settings::new();
-  let state = State::new(settings.to_owned());
+  let state = State::new(settings);
 
   Service::run(state)?;
 

server/src/main.rs

@@ -21,27 +21,12 @@ use super::types::{
   SignalType
 };
 
-pub fn process_incoming_message(messages_pool: Arc<Mutex<MessagesPool>>, signal: String) -> Result<()> {
-  let data = SignalData::from_str(&signal)?;
-
-  if !data.with_message || data.username.is_none() {
-    return Err(IncomingMessageError.into())
-  }
-
-  messages_pool.lock().push(PoolMessage {
-    id: Uuid::new_v4().to_string(),
-    username: data.username.clone().unwrap(),
-    message: data.message.clone().unwrap().trim().to_owned(),
-    from_server: false
-  });
-
-  Ok(())
-}
 pub trait DataManager {
   fn deny_auth(&mut self) -> Result<()>;
   fn auth(&mut self, signal: String) -> Result<SignalType>;
   fn remove_user(&mut self, username: String) -> Result<()>;
   fn process_messages_pool(&mut self, receiver: Receiver<()>) -> Result<()>;
+  fn process_incoming_message(messages_pool: Arc<Mutex<MessagesPool>>, signal: String) -> Result<()>;
 }
 
 impl DataManager for Manager {
@@ -138,4 +123,21 @@ impl DataManager for Manager {
 
     Ok(())
   }
+
+  fn process_incoming_message(messages_pool: Arc<Mutex<MessagesPool>>, signal: String) -> Result<()> {
+    let data = SignalData::from_str(&signal)?;
+  
+    if !data.with_message || data.username.is_none() {
+      return Err(IncomingMessageError.into())
+    }
+  
+    messages_pool.lock().push(PoolMessage {
+      id: Uuid::new_v4().to_string(),
+      username: data.username.clone().unwrap(),
+      message: data.message.clone().unwrap().trim().to_owned(),
+      from_server: false
+    });
+  
+    Ok(())
+  }
 }

server/src/managers/data_manager.rs

@@ -3,48 +3,25 @@ use std::{
     Write, BufReader
   }, 
   time::Duration, 
-  thread, 
-  net::TcpStream, 
+  thread,
   sync::{
-    Arc, 
     mpsc::{
       self, 
       Sender
     }
   }
 };
 use anyhow::Result;
-use parking_lot::Mutex;
 
-use crate::{managers::{data_manager::DataManager, types::SignalType}, messages_pool::MessagesPool, reader::StreamReader};
+use crate::{managers::{data_manager::DataManager, types::SignalType}, reader::StreamReader};
 
-use super::{manager::Manager, data_manager::process_incoming_message};
-
-fn process_signals(stream: TcpStream, messages_pool: Arc<Mutex<MessagesPool>>, sender: Sender<()>) -> Result<()> {
-  let mut reader = BufReader::new(stream.try_clone()?);
-  loop {
-    let data_from_socket = match reader.read_signal(None) {
-      Ok(s) => s,
-      Err(_) => {
-        break;
-      }
-    };
-
-    match process_incoming_message(messages_pool.clone(), data_from_socket) {
-      Ok(_) => (),
-      Err(_) => println!("invalid message")
-    };
-  }
-
-  sender.send(())?;
-
-  Ok(())
-}
+use super::manager::Manager;
 
 pub trait StreamManager {
   fn process_connection(&mut self) -> Result<()>;
   fn process_disconnection(&mut self) -> Result<()>;
   fn send_data(&mut self, data: &str) -> Result<()>;
+  fn process_signals(&mut self, sender: Sender<()>) -> Result<()>;
 }
 
 impl StreamManager for Manager {
@@ -72,14 +49,8 @@ impl StreamManager for Manager {
     };
 
     if let SignalType::Connection = signal_type {
-      let cloned_stream = self.stream.try_clone()?;
-      let cloned_messages_pool = self.messages_pool.clone();
       let (channel_sender, channel_receiver) = mpsc::channel::<()>();
-      thread::spawn(move || -> Result<()> {
-        process_signals(cloned_stream, cloned_messages_pool, channel_sender)?;
-
-        Ok(())
-      });
+      self.process_signals(channel_sender)?;
 
       self.process_messages_pool(channel_receiver)?;
     }
@@ -100,4 +71,32 @@ impl StreamManager for Manager {
     self.stream.write(data.as_bytes())?;
     Ok(())
   }
+
+  fn process_signals(&mut self, sender: Sender<()>) -> Result<()> {
+    let cloned_stream = self.stream.try_clone()?;
+    let cloned_messages_pool = self.messages_pool.clone();
+
+    thread::spawn(move || -> Result<()> {
+      let mut reader = BufReader::new(cloned_stream.try_clone()?);
+      loop {
+        let data_from_socket = match reader.read_signal(None) {
+          Ok(s) => s,
+          Err(_) => {
+            break;
+          }
+        };
+
+        match Self::process_incoming_message(cloned_messages_pool.clone(), data_from_socket) {
+          Ok(_) => (),
+          Err(_) => println!("invalid message")
+        };
+      }
+
+      sender.send(())?;
+
+      Ok(())
+    });
+
+    Ok(())
+  }
 }