added tmp folders and files for V2 system

src/server_v2/client_v2/mod.rs

@@ -0,0 +1,61 @@
+use std::string::ToString;
+use std::sync::{Arc, Mutex, Weak};
+use std::net::TcpStream;
+use crate::server_v2::Serverv2;
+use std::sync::mpsc::{Receiver, Sender, channel, TryRecvError};
+use crate::server_v2::commands_v2::Commandsv2;
+
+#[derive(Clone)]
+pub struct ClientV2 {
+    pub uuid: String,
+    pub username: String,
+    pub address: String,
+
+    stream: Arc<Mutex<TcpStream>>,
+    server_reference: Weak<Serverv2>,
+
+    tx: Sender<Commandsv2>,
+    rx: Receiver<Commandsv2>,
+}
+
+impl ClientV2 {
+    pub fn new(stream: Arc<Mutex<TcpStream>>, server: Arc<Serverv2>, uuid: &String, username: &String, address: &String) -> ClientV2 {
+
+        let (tx, rx) = channel();
+
+        ClientV2 {
+            stream: stream,
+            server_reference: Arc::downgrade(&server),
+
+            tx,
+            rx,
+
+            uuid: uuid.to_string(),
+            username: username.to_string(),
+            address: address.to_string(),
+
+        }
+    }
+
+    pub fn run(&self) {
+
+
+
+        loop {
+            match self.rx.try_recv() {
+                Ok(Command) => {
+
+                }
+                Err(TryRecvError::Empty) => { }
+                Err(TryRecvError::Disconnected) => {
+
+                }
+            }
+        }
+    }
+
+    pub fn get_tx(&self) -> Sender<Commandsv2> {
+        self.tx.clone()
+    }
+}
+

src/server_v2/commands_v2/mod.rs

@@ -0,0 +1,107 @@
+use std::collections::HashMap;
+use std::borrow::Borrow;
+use regex::Regex;
+use std::ops::Index;
+
+pub enum Commands {
+    Request(Option<HashMap<String, String>>),
+    Info(Option<HashMap<String, String>>),
+
+    Connect(Option<HashMap<String, String>>),
+    Disconnect(Option<HashMap<String, String>>),
+
+    ClientUpdate(Option<HashMap<String, String>>),
+    ClientInfo(Option<HashMap<String, String>>),
+    ClientRemove(Option<HashMap<String, String>>),
+    Client(Option<HashMap<String, String>>),
+
+    Success(Option<HashMap<String, String>>),
+    Error(Option<HashMap<String, String>>),
+}
+
+impl Commands {
+    pub fn to_String(&self) -> String {
+
+        let mut out_string = String::new();
+
+        let (command, parameters) = match self {
+            Commands::Info(arguments) => { ("!info:", arguments) },
+            Commands::Connect(arguments) => { ("!connect:", arguments) },
+            Commands::Disconnect(arguments) => { ("!disconnect:", arguments) },
+            Commands::ClientUpdate(arguments) => { ("!clientUpdate:", arguments) },
+            Commands::ClientInfo(arguments) => { ("!clientInfo:", arguments) },
+            Commands::Error(arguments) => { ("!error:", arguments) },
+            _ => { ("!error:", &None) }
+        };
+
+        out_string.push_str(command);
+
+        if parameters.is_some() {
+            let hash_map = parameters.borrow().as_ref().unwrap();
+            for (k, v) in hash_map.iter() {
+                out_string.push_str(" ");
+                out_string.push_str(k.as_str());
+                out_string.push_str(":");
+                out_string.push_str(v.as_str())
+            }
+        }
+
+        out_string
+    }
+
+    pub fn from_string(data: &str) -> Result<Commandsv2, &'static str> {
+        let regex = Regex::new(r###"(\?|!)([a-zA-z0-9]*):|([a-zA-z]*):([a-zA-Z0-9\-\+\[\]{}_=/]+|("(.*?)")+)"###).unwrap();
+        let mut iter = regex.find_iter(data);
+        let command = iter.next().unwrap().as_str();
+
+        println!("command: {:?}", command);
+
+        let mut map: HashMap<String, String> = HashMap::new();
+
+        for i in iter {
+            let parameter = i.as_str().to_string();
+            let mut parts:Vec<&str> = parameter.split(":").collect();
+
+            map.insert(parts.index(0).to_string(), parts.index(1).to_string());
+        }
+
+        let params = if map.capacity() > 1 {Some(map)} else { None };
+
+        match command {
+            "!info:" => Ok(Commands::Info(params)),
+            "!connect:" => Ok(Commands::Connect(params)),
+            "!clientInfo:" => Ok(Commands::ClientInfo(params)),
+            "!clientUpdate:" => Ok(Commands::ClientUpdate(params)),
+            "!disconnect:" => Ok(Commands::Disconnect(params)),
+            "!error:" => Ok(Commands::Error(params)),
+            _ => { Err("NOT IMPLEMENTED") }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test_commands_v2 {
+    use crate::server_v2::commands_v2::Commandsv2;
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_creation_from_string() {
+        let command_result = Commandsv2::from_string("!connect: name:bop host:127.0.0.1 uuid:123456-1234-1234-123456");
+        assert!(command_result.is_ok(), true);
+        let command = command_result.unwrap_or(Commandsv2::Error(None));
+        ()
+    }
+
+    #[test]
+    fn test_to_string() {
+
+        let mut a: HashMap<String, String> = HashMap::new();
+        a.insert("name".to_string(), "michael".to_string());
+        a.insert("host".to_string(), "127.0.0.1".to_string());
+        a.insert("uuid".to_string(), "123456-1234-1234-123456".to_string());
+
+        let command = Commandsv2::Connect(Some(a));
+
+        println!("{:?}", command.to_String())
+    }
+}

src/server_v2/mod.rs

@@ -0,0 +1,110 @@
+pub mod client_v2;
+pub mod commands_v2;
+
+use client_v2::ClientV2;
+use std::{
+    collections::{HashMap, VecDeque},
+    io,
+    thread,
+    sync::{
+        mpsc::{channel, Sender, Receiver},
+        Arc,
+        Mutex,
+    },
+    ops::Deref,
+    borrow::Borrow,
+    time::Duration,
+    net::TcpListener,
+    io::Read,
+};
+use crate::server_v2::commands_v2::Commandsv2;
+use crate::lib::ThreadPool;
+use std::sync::mpsc::TryRecvError;
+use crate::server_v2::commands_v2::Commandsv2::Disconnect;
+
+enum server_message {
+    start,
+    stop,
+    kick(String),
+}
+
+pub struct Serverv2 {
+    name: String,
+    host: String,
+    owner: String,
+
+    rx: Arc<Mutex<Receiver<server_message>>>,
+    tx: Arc<Mutex<Sender<server_message>>>,
+
+    connected_clients: Arc<Mutex<HashMap<String, ClientV2>>>,
+    thread_pool: ThreadPool,
+}
+
+impl Serverv2 {
+    pub fn new(name: String, host: String, owner: String) -> Serverv2 {
+
+        let (tx,rx) = channel();
+
+        Serverv2 {
+            name,
+            host,
+            owner,
+
+            rx: Arc::new(Mutex::new(rx)),
+            tx: Arc::new(Mutex::new(tx)),
+
+            connected_clients: Arc::new(Mutex::new(HashMap::new())),
+            thread_pool: ThreadPool::new(16)
+        }
+    }
+
+    pub fn start(&self) -> Result<(), io::Error> {
+        let listener = TcpListener::bind("0.0.0.0:6001")?;
+
+
+
+
+        // accepting clients
+        thread::spawn(move || {
+            match rx.lock().unwrap().try_recv() {
+                Ok(a) => {}
+                Err(TryRecvError::Empty) => {}
+                Err(TryRecvError::Disconnected) => {
+                    self.connected_clients.lock()
+                        .unwrap()
+                        .iter()
+                        .map(|(id, client)| {
+                            let tx = client.get_tx();
+                            tx.send(Disconnect(None));
+                        });
+                }
+            }
+
+        });
+
+        Ok(())
+    }
+
+    pub fn stop(&self) {
+    }
+
+    pub fn add_client(&self, client: ClientV2) -> Result<(), &str> {
+        let mut client_map = self.connected_clients.lock().unwrap();
+        if client_map.contains_key(client.uuid.as_str()) {
+            return Err("!exists:");
+        }
+
+        client_map.insert(client.uuid.to_string(), client);
+
+        self.thread_pool.execute(|| {client.run()});
+        Ok(())
+    }
+
+    pub fn get_tx(&self, mesage: server_message) {
+        self.tx.clone();
+    }
+
+    fn log(mesaage: &str) {
+        println!("Server: {}", mesaage);
+    }
+}