implemented basic connection handling in the server

src/lib/server/client_management/client/mod.rs

@@ -32,7 +32,7 @@ pub enum ClientMessage {
 /// 
 /// - stream: The socket for the connected client.
 /// - owner: An optional reference to the owning object.
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
 pub struct Client {
   pub uuid: Uuid,
   username: String,

src/lib/server/client_management/mod.rs

@@ -2,6 +2,7 @@ pub mod client;
 mod traits;
 
 // use crate::lib::server::ServerMessages;
+use crate::lib::server::ServerMessages;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::sync::Weak;
@@ -20,38 +21,32 @@ enum ClientManagerMessages {}
 
 /// # ClientManager
 /// This struct manages all connected users
+#[derive(Debug)]
 pub struct ClientManager {
   clients: Mutex<Vec<Arc<Client>>>,
 
-  weak_self: Mutex<Option<Weak<Self>>>,
+  // weak_self: Mutex<Option<Weak<Self>>>,
 
-	// server_channel: Sender<ServerMessages>,
+	server_channel: Sender<ServerMessages>,
 
   sender: Sender<ClientManagerMessages>,
   receiver: Receiver<ClientManagerMessages>,
 }
 
 impl ClientManager {
-  pub fn new(/*server_channel:  Sender<ServerMessages> */) -> Arc<Self> {
+  pub fn new(server_channel:  Sender<ServerMessages>) -> Arc<Self> {
 
     let (sender, receiver) = unbounded();
 
     Arc::new(ClientManager {
       clients: Mutex::default(),
 
-      weak_self: Mutex::default(),
+			server_channel,
-
-			// server_channel,
 
       sender,
       receiver,
     })
   }
-
-  fn set_ref(&self, reference: Arc<Self>) {
-    let mut lock = self.weak_self.lock().unwrap();
-    *lock = Some(Arc::downgrade(&reference));
-	}
 }
 
 impl TClientManager<Client, ClientMessage> for ClientManager {

src/lib/server/mod.rs

@@ -1,15 +1,21 @@
 pub mod client_management;
 
-use crossbeam_channel::{Sender, Receiver, unbounded};
+
 use std::sync::{Arc, Weak, Mutex};
 use std::net::TcpListener;
+use std::io::Write;
+use std::io::Read;
+
+use crossbeam_channel::{Sender, Receiver, unbounded};
 
 use crate::lib::server::client_management::ClientManager;
 use crate::lib::Foundation::{IOwner, IOwned, ICooperative};
 use client_management::client::Client;
+use crate::lib::commands::Commands;
 
-enum ServerMessages {
+#[derive(Debug)]
-	ClientConnected(Client),
+pub enum ServerMessages {
+	ClientConnected(Arc<Client>),
 }
 
 pub struct Server {
@@ -27,7 +33,7 @@ impl Server {
 
 		Arc::new(Server {
 			server_socket: listener,
-			client_manager: ClientManager::new(/*sender*/),
+			client_manager: ClientManager::new(sender.clone()),
 			
 			sender,
 			receiver,
@@ -38,5 +44,34 @@ impl Server {
 impl ICooperative for Server{
 	fn tick(&self) {
 
+    let mut buffer = vec![0; 1024];
+
+    // get connections 
+    for connection in self.server_socket.incoming() {
+      match connection {
+        Ok(mut stream) => {
+          let _ = stream.write(Commands::Request(None).to_string().as_bytes());
+          let _ = stream.read(&mut buffer);
+
+          let command = Commands::from(&mut buffer);
+
+          match command {
+            Commands::Info(None) => {let _ = stream.write("todo".as_bytes());}
+            _ => {let _ = stream.write("not implemented!".as_bytes());}
+          }
+
+        },
+        _ => println!("!connection error occured!"),
+      }
+    }
+
+
+
+    // message loop
+    for message in self.receiver.iter() {
+      match message {
+        ServerMessages::ClientConnected(client) => println!("client connected: {:?}", client),
+      }
+    }
 	}
 }

src/main.rs

@@ -3,6 +3,7 @@ mod lib;
 use clap::{App, Arg};
 
 use crate::lib::server::Server;
+use crate::lib::Foundation::ICooperative;
  
 fn main() {
   let _args = App::new("--rust chat server--")
@@ -18,7 +19,11 @@ fn main() {
       .takes_value(true))
     .get_matches();
 
-	let mut server = Server::new();
+	let server = Server::new();
+
+  loop {
+    server.tick();
+  }
 }