added new server program crate

server/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "server"
+version = "0.1.0"
+authors = ["michael-bailey <mickyb18a@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = "2.33.3"
+uuid = {version = "0.8", features = ["serde", "v4"]}
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+crossbeam = "0.8.0"
+crossbeam-channel = "0.5.0"
+crossbeam-queue = "0.3.1"
+
+[dependencies.foundation]
+path = '../foundation'

server/src/client.rs

@@ -0,0 +1,174 @@
+use crate::messages::ClientMessage;
+use crate::messages::ServerMessage;
+use std::cmp::Ordering;
+use std::net::TcpStream;
+use std::sync::Mutex;
+use std::sync::Arc;
+use std::io::{BufReader, BufWriter};
+use std::io::BufRead;
+
+use uuid::Uuid;
+use serde::{Serialize};
+use crossbeam_channel::{Sender, Receiver, unbounded};
+
+use foundation::prelude::{ICooperative, IMessagable};
+use foundation::messages::client::{ClientStreamIn};
+
+
+
+/// # Client
+/// This struct represents a connected user.
+/// 
+/// ## Attrubutes
+/// - uuid: The id of the connected user.
+/// - username: The username of the connected user.
+/// - address: The the address of the connected client.
+/// 
+/// - stream: The socket for the connected client.
+/// - owner: An optional reference to the owning object.
+#[derive(Debug, Serialize)]
+pub struct Client {
+  pub uuid: Uuid,
+  username: String,
+  address: String,
+
+	// non serializable
+	#[serde(skip)]
+  server_channel: Option<Sender<ServerMessage>>,
+
+  #[serde(skip)]
+  input: Sender<ClientMessage>,
+
+  #[serde(skip)]
+  output: Receiver<ClientMessage>,
+
+	#[serde(skip)]
+  stream: Mutex<Option<TcpStream>>,
+
+  #[serde(skip)]
+  stream_reader: Mutex<Option<BufReader<TcpStream>>>,
+
+  #[serde(skip)]
+  stream_writer: Mutex<Option<BufWriter<TcpStream>>>,
+
+}
+
+// client funciton implmentations
+impl Client {
+  pub fn new(
+		uuid: String,
+		username: String,
+		address: String,
+		stream: TcpStream,
+		server_channel: Sender<ServerMessage>
+	) -> Arc<Client> {
+    let (sender, receiver) = unbounded();
+
+    let out_stream = stream.try_clone().unwrap();
+    let in_stream = stream.try_clone().unwrap();
+
+    Arc::new(Client {
+      username,
+      uuid: Uuid::parse_str(&uuid).expect("invalid id"),
+      address,
+
+      server_channel: Some(server_channel),
+
+      input: sender,
+      output: receiver,
+
+      stream: Mutex::new(Some(stream)),
+
+      stream_reader: Mutex::new(Some(BufReader::new(in_stream))),
+      stream_writer: Mutex::new(Some(BufWriter::new(out_stream))),
+    })
+  }
+
+	// MARK: - removeable
+  pub fn send(&self, _bytes: Vec<u8>) -> Result<(), &str> { todo!() }
+  pub fn recv(&self) -> Option<Vec<u8>> { todo!() }
+	// Mark: end -
+}
+
+impl IMessagable<ClientMessage, Sender<ServerMessage>> for Client{
+	fn send_message(&self, msg: ClientMessage) {
+		self.input.send(msg).expect("failed to send message to client.");
+	}
+  fn set_sender(&self, sender: Sender<ServerMessage>) {
+
+  }
+}
+
+// cooperative multitasking implementation
+impl ICooperative for Client {
+	fn tick(&self) {
+    // aquire locks (so value isn't dropped)
+    let mut reader_lock = self.stream_reader.lock().unwrap();
+    let mut writer_lock = self.stream_writer.lock().unwrap();
+
+    // aquiring mutable buffers
+    let reader = reader_lock.as_mut().unwrap();
+    let _writer = writer_lock.as_mut().unwrap();
+
+    // create buffer
+    let mut buffer = String::new();
+
+    // loop over all lines that have been sent.
+    while let Ok(_size) = reader.read_line(&mut buffer) {
+      let command = serde_json::from_str::<ClientStreamIn>(buffer.as_str()).unwrap();
+
+      match command {
+        ClientStreamIn::Disconnect {id} => println!("got Disconnect from id: {:?}", id),
+        _ => println!("New command found"),
+      }
+    }
+
+
+    // handle incomming messages
+
+	}
+}
+
+// default value implementation
+impl Default for Client {
+	fn default() -> Self {
+		let (sender, reciever) = unbounded();
+		Client {
+			username: "generic_client".to_string(),
+      uuid: Uuid::new_v4(),
+      address: "127.0.0.1".to_string(),
+
+		  output: reciever,
+			input: sender,
+
+      server_channel: None,
+
+      stream: Mutex::new(None),
+
+      stream_reader: Mutex::new(None),
+      stream_writer: Mutex::new(None),
+		}
+	}
+}
+
+// MARK: - used for sorting.
+impl PartialEq for Client {
+      fn eq(&self, other: &Self) -> bool {
+        self.uuid == other.uuid
+    }
+}
+
+impl Eq for Client {
+}
+
+impl PartialOrd for Client {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+			Some(self.cmp(other))
+	}
+}
+
+impl Ord for Client {
+      fn cmp(&self, other: &Self) -> Ordering {
+        self.uuid.cmp(&other.uuid)
+    }
+}

server/src/client_manager.rs

@@ -0,0 +1,120 @@
+// use crate::lib::server::ServerMessages;
+use crate::messages::ServerMessage;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::collections::HashMap;
+
+use crossbeam_channel::{unbounded, Receiver, Sender};
+use uuid::Uuid;
+
+use crate::client::Client;
+use foundation::prelude::IMessagable;
+use foundation::prelude::ICooperative;
+
+enum ClientManagerMessage {
+  #[allow(dead_code)]
+  DropAll,
+  #[allow(dead_code)]
+  MessageClient,
+}
+
+/// # ClientManager
+/// This struct manages all connected users
+#[derive(Debug)]
+pub struct ClientManager {
+  clients: Mutex<HashMap<Uuid, Arc<Client>>>,
+
+	server_channel: Sender<ServerMessage>,
+
+  sender: Sender<ClientManagerMessage>,
+  receiver: Receiver<ClientManagerMessage>,
+}
+
+impl ClientManager {
+  pub fn new(server_channel:  Sender<ServerMessage>) -> Arc<Self> {
+
+    let (sender, receiver) = unbounded();
+
+    Arc::new(ClientManager {
+      clients: Mutex::default(),
+
+			server_channel,
+
+      sender,
+      receiver,
+    })
+  }
+}
+
+// impl TClientManager<Client, ClientMessage> for ClientManager {
+//   fn add_client(&self, client: std::sync::Arc<Client>) {
+//     self.clients.lock().unwrap().insert(client.uuid, client);
+//   }
+
+//   fn remove_client(&self, uuid: Uuid) {
+//     let _ = self.clients.lock().unwrap().remove(&uuid);
+//   }
+
+//   fn send_message_to_client(&self, uuid: Uuid, msg: ClientMessage) {
+//     let clients = self.clients.lock().unwrap();
+//     let client = clients.get(&uuid).unwrap();
+//     client.send_message(msg);
+//   }
+// }
+
+impl IMessagable<ClientManagerMessage, Sender<ServerMessage>> for ClientManager {
+	fn send_message(&self, msg: ClientManagerMessage) {
+
+  }
+  fn set_sender(&self, sender: Sender<ServerMessage>) {
+
+  }
+}
+
+impl ICooperative for ClientManager {
+  fn tick(&self) {
+
+    for message in self.receiver.iter() {
+      match message {
+        ClientManagerMessage::DropAll => {
+          println!("cannot drop all clients yet")
+        }
+        _ => println!("[Client Manager]: method not implemented")
+      }
+    }
+
+    // allocate time for clients.
+    let clients = self.clients.lock().unwrap();
+    let _ = clients.iter().map(|(_uuid, client)| client.tick());
+  }
+}
+
+
+#[cfg(test)]
+mod test {
+  // use super::ClientManager;
+  // use std::sync::Arc;
+	// use crate::lib::Foundation::{IOwner};
+
+  #[test]
+  fn test_get_ref() {
+    // let client_manager = ClientManager::new();
+    // let _cm_ref = client_manager.get_ref();
+    // assert_eq!(Arc::weak_count(&client_manager), 2);
+  }
+
+  #[test]
+  fn test_add_client() {
+    todo!()
+  }
+
+  #[test]
+  fn test_remove_client() {
+    todo!()
+  }
+
+  #[test]
+  fn test_remove_all_clients() {
+    todo!()
+  }
+}

server/src/main.rs

@@ -0,0 +1,31 @@
+pub mod server;
+pub mod network_manager;
+pub mod client;
+pub mod client_manager;
+pub mod messages;
+
+use clap::{App, Arg};
+
+use foundation::prelude::ICooperative;
+use server::Server;
+ 
+fn main() {
+  let _args = App::new("--rust chat server--")
+    .version("0.1.5")
+    .author("Mitchel Hardie <mitch161>, Michael Bailey <michael-bailey>")
+    .about("this is a chat server developed in rust, depending on the version one of two implementations will be used")
+    .arg(
+      Arg::with_name("config")
+      .short("p")
+      .long("port")
+      .value_name("PORT")
+			.help("sets the port the server runs on.")
+      .takes_value(true))
+    .get_matches();
+
+	let server = Server::new();
+
+  loop {
+    server.tick();
+  }
+}

server/src/messages.rs

@@ -0,0 +1,13 @@
+use uuid::Uuid;
+use std::sync::Arc;
+
+use crate::client::Client;
+
+pub enum ClientMessage {
+  Disconnect
+}
+
+pub enum ServerMessage {
+  ClientConnected(Arc<Client>),
+  ClientDisconnected(Uuid)
+}

server/src/network_manager.rs

@@ -0,0 +1,95 @@
+use crate::client::Client;
+use crate::messages::ServerMessage;
+use std::io::BufWriter;
+use std::io::BufReader;
+use std::sync::Arc;
+use crate::server::ServerMessages;
+use std::net::TcpListener;
+use std::io::Write;
+use std::io::BufRead;
+
+use crossbeam_channel::{Sender};
+
+use foundation::prelude::ICooperative;
+use foundation::messages::network::{NetworkSockIn, NetworkSockOut};
+
+pub struct NetworkManager {
+  listener: TcpListener,
+  server_channel: Sender<ServerMessage>,
+}
+
+impl NetworkManager {
+  pub fn new(
+		port: String, 
+		server_channel: Sender<ServerMessage>
+	) -> Arc<NetworkManager> {
+    let mut address = "0.0.0.0:".to_string();
+    address.push_str(&port);
+
+		let listener = TcpListener::bind(address)
+      .expect("Could not bind to address");
+
+    Arc::new(NetworkManager {
+      listener,
+      server_channel,
+    })
+  }
+}
+
+impl ICooperative for NetworkManager {
+  fn tick(&self) {
+    // get all new connections
+		// handle each request
+		for connection in self.listener.incoming() {
+			if let Ok(stream) = connection {
+
+				// create buffered writers
+				let mut reader = BufReader::new(stream.try_clone().unwrap());
+				let mut writer = BufWriter::new(stream.try_clone().unwrap());
+
+				let mut buffer = String::new();
+
+				// request is always sent on new connection
+				writer.write_all(
+					serde_json::to_string(&NetworkSockOut::Request).unwrap().as_bytes()
+				).unwrap_or_default();
+				writer.write_all(b"\n").unwrap_or_default();
+				writer.flush().unwrap_or_default();
+
+				// read the new request into a buffer
+				let res = reader.read_line(&mut buffer);
+				if res.is_err() {continue;}
+
+				// turn into enum for pattern matching
+				if let Ok(request) = serde_json::from_str::<NetworkSockIn>(&buffer) {
+					// perform action based on the enum
+					match request {
+						NetworkSockIn::Info => {
+							writer.write_all(
+								serde_json::to_string(
+									&NetworkSockOut::GotInfo {
+										server_name: "oof", 
+										server_owner: "michael"
+									}
+								).unwrap().as_bytes()
+							).unwrap();
+							writer.flush().unwrap();
+						}
+						NetworkSockIn::Connect { uuid, username, address } => {
+							let new_client = Client::new(
+                uuid,
+								username,
+								address,
+								stream.try_clone().unwrap(),
+								self.server_channel.clone()
+							);
+							self.server_channel.send(
+								ServerMessage::ClientConnected(new_client)
+							).unwrap_or_default();
+						}
+					}
+				}
+			}
+		}
+  }
+}

server/src/server.rs

@@ -0,0 +1,59 @@
+use crate::messages::ServerMessage;
+use uuid::Uuid;
+
+use std::sync::Arc;
+use crossbeam_channel::{Receiver, unbounded};
+
+use foundation::prelude::ICooperative;
+use crate::client_manager::ClientManager;
+use crate::network_manager::NetworkManager;
+
+/// # ServerMessages
+/// This is used internally 
+#[derive(Debug)]
+pub enum ServerMessages<TClient> {
+	ClientConnected(Arc<TClient>),
+
+  #[allow(dead_code)]
+  ClientDisconnected(Uuid),
+}
+
+pub struct Server {
+	client_manager: Arc<ClientManager>,
+  network_manager: Arc<NetworkManager>,
+
+	receiver: Receiver<ServerMessage>,
+}
+
+impl Server {
+	pub fn new() -> Arc<Server> {
+		let (sender, receiver) = unbounded();
+
+		Arc::new(Server {
+			client_manager: ClientManager::new(sender.clone()),
+
+      network_manager: NetworkManager::new("5600".to_string(), sender.clone()),
+			receiver,
+		})
+	}
+}
+
+impl ICooperative for Server{
+	fn tick(&self) {
+
+		// handle new messages loop
+		for message in self.receiver.try_iter() {
+			match message {
+				ServerMessage::ClientConnected(client) => {
+				},
+				ServerMessage::ClientDisconnected(uuid) => {
+				}
+			}
+		}
+
+		// alocate time for other components
+		self.network_manager.tick();
+		self.client_manager.tick();
+
+	}
+}

src/main.rs

@@ -1,84 +0,0 @@
-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--")
-    .version("0.1.5")
-    .author("Mitchel Hardie <mitch161>, Michael Bailey <michael-bailey>")
-    .about("this is a chat server developed in rust, depending on the version one of two implementations will be used")
-    .arg(
-      Arg::with_name("config")
-      .short("p")
-      .long("port")
-      .value_name("PORT")
-			.help("sets the port the server runs on.")
-      .takes_value(true))
-    .get_matches();
-
-	let server = Server::new();
-
-  loop {
-    server.tick();
-  }
-}
-
-
-// MARK: - general testing zone
-// #[cfg(test)]
-// mod tests {
-//     use crate::server::server_profile::Server;
-//     use crate::client_api::ClientApi;
-//     use std::collections::HashMap;
-//     use crate::commands::Commands;
-//     use std::{thread, time};
-
-//     #[test]
-//     fn test_server_info() {
-//         // setup the server
-//         let name = "Server-01";
-//         let address = "0.0.0.0:6000";
-//         let owner = "noreply@email.com";
-
-//         let mut server = Server::new(name, address, owner);
-//         let result = server.start();
-
-//         assert_eq!(result.is_ok(), true);
-
-//         let dur = time::Duration::from_millis(1000);
-//         thread::sleep(dur);
-        
-//         let api = ClientApi::get_info("127.0.0.1:6000");
-//         assert_eq!(api.is_ok(), true);
-//         if let Ok(api) = api {
-//             println!("received: {:?}", api);
-//             let mut map = HashMap::new();
-//             map.insert("name".to_string(), name.to_string());
-//             map.insert("owner".to_string(), owner.to_string());
-
-//             let expected = Commands::Info(Some(map));
-//             println!("expected: {:?}", expected);
-//             assert_eq!(api, expected);
-//         }
-//     }
-
-//     #[test]
-//     fn test_server_connect() {
-//         let name = "Server-01";
-//         let address = "0.0.0.0:6001";
-//         let owner = "noreply@email.com";
-
-//         let mut server = Server::new(name, address, owner);
-//         let _ = server.start().unwrap();
-
-//         let api_result = ClientApi::new(address);
-//         assert_eq!(api_result.is_ok(), true);
-//         if api_result.is_ok() {
-//             std::thread::sleep(std::time::Duration::from_secs(2));
-//         }
-//     }
-// }
-