After article fixes

Author: idavydoff

client/src/connection.rs

@@ -31,48 +31,30 @@ impl Connection {
     );
     let mut connection = TcpStream::connect(address)?;
     connection.write_all(signal.to_string().as_bytes())?;
-    let reader = io::BufReader::new(connection.try_clone()?);
+    let reader = BufReader::new(connection.try_clone()?);
 
     let mut instance = Connection {
       stream: connection,
       reader
     };
 
-    let data_from_socket = instance.read_signal(None)?;
+    let data_from_socket = instance.read_signal()?;
     if data_from_socket.contains(&AuthStatus::DENIED.to_string()) {
       return Err(Error::new(ErrorKind::ConnectionAborted, "Access denied"));
     }
 
     return Ok(instance)
   }
 
-  pub fn read_signal(&mut self, max_read_try: Option<u8>) -> io::Result<String> {
+  pub fn read_signal(&mut self) -> io::Result<String> {
     let mut res_line = String::new();
     let mut headers_read = false;
-    let mut fail_reads_count: u8 = 0;
     loop {
       let mut buf_line = String::new();
       match self.reader.read_line(&mut buf_line) {
-        Err(e) => {
-          match e.kind() {
-            io::ErrorKind::WouldBlock => {
-              if let Some(max_fails) = max_read_try {
-                fail_reads_count += 1;
-                if fail_reads_count == max_fails {
-                  return Err(Error::new(ErrorKind::ConnectionAborted, "Connection aborted"))
-                }
-              }
-              continue;
-            },
-            _ => panic!("Got an error: {}", e),
-          }
-        },
-        Ok(m) => {
-          if m == 0 {
-            return Err(Error::new(ErrorKind::BrokenPipe, "Connection closed"))
-          }
-          m
-        },
+        Err(e) => panic!("Got an error: {}", e),
+        Ok(0) => return Err(Error::new(ErrorKind::BrokenPipe, "Connection closed")),
+        Ok(_) => (),
       };
       res_line.push_str(&buf_line);
 

client/src/service.rs

@@ -52,11 +52,9 @@ impl Service {
     let mut connection = self.connection.clone();
     thread::spawn(move || -> io::Result<()> {
       loop {
-        let data_from_socket = match connection.read_signal(None) {
+        let data_from_socket = match connection.read_signal() {
           Ok(v) => v,
-          Err(_) => {
-            break;
-          }
+          Err(_) => break
         };
         let signal = SignalData::from_str(&data_from_socket);
         let mut messages = messages.lock();
@@ -74,13 +72,19 @@ impl Service {
               );
             }
             else {
-              messages.push(format!("<{}> {}", s.username.unwrap(), s.message.unwrap()));
+              messages.push(
+                format!(
+                  "<{}> {}", 
+                  s.username.unwrap(), 
+                  s.message.unwrap()
+                )
+              );
             }
           }
         }
         match tx.send(()) {
           Ok(_) => {},
-          Err(_) => continue
+          Err(_) => break
         };
       }
 
@@ -101,30 +105,24 @@ impl Service {
           Err(_) => break
         };
         print!("{}", termion::clear::All);
-        for (index, m) in (&*messages.lock()).iter().enumerate() {
+        for (index, m) in messages.lock().iter().enumerate() {
           if index == 0 {
-            write!(
-              std::io::stdout(), 
-              "\r\n{m}\r\n"
-            )?;
+            print!("\r\n{m}\r\n");
           }
           else {
-            write!(
-              std::io::stdout(), 
-              "{m}\r\n"
-            )?;
+            print!("{m}\r\n");
           }
         }
         let input = user_input.lock().clone();
-        write!(
-          std::io::stdout(), 
+        print!(
           "{}{}{} >{} {}", 
           termion::color::Bg(termion::color::White), 
           termion::color::Fg(termion::color::Black), 
           username, 
           termion::style::Reset,
           input
-        )?;
+        );
+
         std::io::stdout().flush()?;
       }
       Ok(())
@@ -145,8 +143,8 @@ impl Service {
 
   pub fn read_inputs(&mut self) {
     let stdout = io::stdout().into_raw_mode().unwrap(); // НЕЛЬЗЯ УБИРАТЬ
-    let mut stdin = termion::async_stdin().keys();
-  
+    let mut stdin = io::stdin().keys();
+
     loop {
       let input = stdin.next();
 
@@ -158,7 +156,7 @@ impl Service {
             if ms == "" {
               match self.state.chat_reload_sender.send(()) {
                 Ok(_) => {},
-                Err(_) => continue, 
+                Err(_) => break, 
               };
               continue;
             }
@@ -178,15 +176,15 @@ impl Service {
             self.state.user_input.lock().pop();
             match self.state.chat_reload_sender.send(()) {
               Ok(_) => {},
-              Err(_) => continue, 
+              Err(_) => break, 
             };
           }
           termion::event::Key::Char(k) => {
             println!("{k}");
             self.state.user_input.lock().push_str(&k.to_string());
             match self.state.chat_reload_sender.send(()) {
               Ok(_) => {},
-              Err(_) => continue, 
+              Err(_) => break, 
             };
           },
           _ => {

client/src/state.rs

@@ -8,9 +8,7 @@ use std::{
     Arc
   }, 
   io::{
-    self, 
-    BufReader, 
-    BufRead, 
+    self,
     Write
   }
 };

server/src/main.rs

@@ -10,6 +10,7 @@ mod service;
 mod managers;
 mod messages_pool;
 mod reader;
+mod types;
 
 fn main() -> Result<()> {
   let settings = Settings::new();

server/src/managers/data_manager.rs

@@ -9,10 +9,7 @@ use uuid::Uuid;
 
 use crate::messages_pool::{PoolMessage, MessagesPool};
 use crate::state::UserData;
-
-use super::manager::Manager;
-use super::stream_manager::StreamManager;
-use super::types::{
+use crate::types::{
   AuthStatus, 
   SignalData, 
   SignalHeader, 
@@ -21,9 +18,12 @@ use super::types::{
   SignalType
 };
 
+use super::manager::Manager;
+use super::stream_manager::StreamManager;
+
 pub trait DataManager {
   fn deny_auth(&mut self) -> Result<()>;
-  fn auth(&mut self, signal: String) -> Result<SignalType>;
+  fn auth(&mut self, signal: String) -> Result<()>;
   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<()>;
@@ -40,7 +40,7 @@ impl DataManager for Manager {
     Ok(())
   }
 
-  fn auth(&mut self, signal: String) -> Result<SignalType> {
+  fn auth(&mut self, signal: String) -> Result<()> {
     let data = SignalData::from_str(&signal)?;
 
     match data.signal_type.unwrap() {
@@ -73,7 +73,7 @@ impl DataManager for Manager {
     );
 
     self.send_data(&response.to_string())?;
-    Ok(data.signal_type.unwrap())
+    Ok(())
   }
 
   fn remove_user(&mut self, username: String) -> Result<()> {
@@ -114,7 +114,7 @@ impl DataManager for Manager {
           if message.from_server {
             syg_vec.push(SignalHeader::ServerMessage);
           }
-          let response = SignalData::new(syg_vec,Some(&message.message));
+          let response = SignalData::new(syg_vec, Some(&message.message));
           self.send_data(&response.to_string())?;
         }
       }

server/src/managers/mod.rs

@@ -1,6 +1,5 @@
 mod manager;
 mod stream_manager;
 mod data_manager;
-pub mod types;
 
 pub use manager::Manager;

server/src/managers/stream_manager.rs

@@ -2,18 +2,15 @@ use std::{
   io::{
     Write, BufReader
   }, 
-  time::Duration, 
   thread,
-  sync::{
-    mpsc::{
-      self, 
-      Sender
-    }
+  sync::mpsc::{
+    self, 
+    Sender
   }
 };
 use anyhow::Result;
 
-use crate::{managers::{data_manager::DataManager, types::SignalType}, reader::StreamReader};
+use crate::{managers::data_manager::DataManager, reader::StreamReader};
 
 use super::manager::Manager;
 
@@ -26,35 +23,29 @@ pub trait StreamManager {
 
 impl StreamManager for Manager {
   fn process_connection(&mut self) -> Result<()> {
-    self.stream.set_read_timeout(Some(Duration::from_millis(1000)))?;
     println!("Connection established - {}", self.connected_peer_addr);
 
     let auth_data = match BufReader::new(
       self.stream.try_clone()?
-    ).read_signal(Some(25)) {
+    ).read_signal() {
       Ok(v) => v,
       Err(_) => {
         self.process_disconnection()?;
         return Ok(())
       }
     };
 
-    let signal_type = match self.auth(auth_data.clone()) {
-      Ok(v) => v,
-      Err(_) => {
-        self.deny_auth()?;
-        self.process_disconnection()?;
-        return Ok(())
-      }
-    };
-
-    if let SignalType::Connection = signal_type {
-      let (channel_sender, channel_receiver) = mpsc::channel::<()>();
-      self.process_signals(channel_sender)?;
-      
-      self.process_messages_pool(channel_receiver)?;
+    if self.auth(auth_data.clone()).is_err() {
+      self.deny_auth()?;
+      self.process_disconnection()?;
+      return Ok(())
     }
 
+    let (channel_sender, channel_receiver) = mpsc::channel::<()>();
+    self.process_signals(channel_sender)?;
+    
+    self.process_messages_pool(channel_receiver)?;
+
     self.process_disconnection()?;
     Ok(())
   }
@@ -79,7 +70,7 @@ impl StreamManager for Manager {
     thread::spawn(move || -> Result<()> {
       let mut reader = BufReader::new(cloned_stream.try_clone()?);
       loop {
-        let data_from_socket = match reader.read_signal(None) {
+        let data_from_socket = match reader.read_signal() {
           Ok(s) => s,
           Err(_) => {
             break;

server/src/messages_pool.rs

@@ -39,9 +39,10 @@ impl MessagesPool {
 
   pub fn push(&mut self, v: PoolMessage) {
     if self.length == 256 {
-      let mut new_indexes: HashMap<String, u8> = HashMap::new();
       self.pool.pop_front();
       self.pool.push_back(v);
+
+      let mut new_indexes: HashMap<String, u8> = HashMap::new();
       for (index, message) in self.pool.iter().enumerate() {
         new_indexes.insert(message.id.clone(), index as u8);
       }

server/src/reader.rs

@@ -1,39 +1,21 @@
 use std::{io::{BufReader, self, BufRead, Error, ErrorKind}, self, net::TcpStream};
 
-use crate::managers::types::SignalHeader;
+use crate::types::SignalHeader;
 
 pub trait StreamReader {
-  fn read_signal(&mut self, max_read_try: Option<u8>) -> io::Result<String>;
+  fn read_signal(&mut self) -> io::Result<String>;
 }
 
 impl StreamReader for BufReader<TcpStream> {
-  fn read_signal(&mut self, max_read_try: Option<u8>) -> io::Result<String> {
+  fn read_signal(&mut self) -> io::Result<String> {
     let mut res_line = String::new();
     let mut headers_read = false;
-    let mut fail_reads_count: u8 = 0;
     loop {
       let mut buf_line = String::new();
       match self.read_line(&mut buf_line) {
-        Err(e) => {
-          match e.kind() {
-            io::ErrorKind::WouldBlock => {
-              if let Some(max_fails) = max_read_try {
-                fail_reads_count += 1;
-                if fail_reads_count == max_fails {
-                  return Err(Error::new(ErrorKind::ConnectionAborted, "boom boom"))
-                }
-              }
-              continue;
-            },
-            _ => return Err(Error::new(ErrorKind::ConnectionAborted, "boom boom"))
-          }
-        },
-        Ok(m) => {
-          if m == 0 {
-            return Err(Error::new(ErrorKind::BrokenPipe, "boom boom"))
-          }
-          m
-        },
+        Err(_) => return Err(Error::new(ErrorKind::ConnectionAborted, "boom boom")),
+        Ok(0) => return Err(Error::new(ErrorKind::BrokenPipe, "boom boom")),
+        Ok(m) => m,
       };
       res_line.push_str(&buf_line);