British-Information-Technologies
/
ChatKit-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added bug fixes from unit tests

This commit is contained in:
Mitchell 2020-07-31 20:22:05 +01:00
parent 5ced20099a
commit fc6e87c8bf
3 changed files with 93 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/server/client/client_profile.rs
View File

@ -68,8 +68,8 @@ impl<'a> Client<'a> {
} }
pub fn handle_connection(&mut self){ pub fn handle_connection(&mut self){
self.stream.set_read_timeout(Some(Duration::from_millis(3000))).unwrap(); //self.stream.set_read_timeout(Some(Duration::from_millis(2000))).unwrap();
//let mut buffer = [0; 1024]; self.stream.set_nonblocking(true).expect("set_nonblocking call failed");
while self.connected { while self.connected {
match self.rx_channel.try_recv() { match self.rx_channel.try_recv() {
@ -139,7 +139,7 @@ impl<'a> Client<'a> {
self.server.remove_client(self.uuid.as_str()); self.server.remove_client(self.uuid.as_str());
//self.stream.shutdown(Shutdown::Both).expect("shutdown call failed"); self.stream.shutdown(Shutdown::Both).expect("shutdown call failed");
let params: HashMap<String, String> = [(String::from("uuid"), self.uuid.clone())].iter().cloned().collect(); let params: HashMap<String, String> = [(String::from("uuid"), self.uuid.clone())].iter().cloned().collect();
let command = Commands::ClientRemove(Some(params)); let command = Commands::ClientRemove(Some(params));
@ -170,7 +170,7 @@ impl<'a> Client<'a> {
} }
}, },
Err(_) => { Err(_) => {
println!("no data read"); //println!("no data read");
}, },
} }
} }
@ -192,13 +192,12 @@ impl<'a> Client<'a> {
let command = Commands::from(&buffer); let command = Commands::from(&buffer);
Ok(command) Ok(command)
//match self.get_stream().read(&mut buffer) {
// Ok(_) => Commands::from(&buffer),
// Err(_) => Commands::Error(None),
//}
} }
fn confirm_success(&self){ fn confirm_success(&self){
self.stream.set_nonblocking(false).expect("set_nonblocking call failed");
self.stream.set_read_timeout(Some(Duration::from_millis(3000))).expect("set_read_timeout call failed");
match self.read_data() { match self.read_data() {
Ok(command) => { Ok(command) => {
match command { match command {
@ -211,8 +210,15 @@ impl<'a> Client<'a> {
}, },
} }
}, },
Err(_) => println!("no success read"), Err(_) => {
println!("no success read");
let error = Commands::Error(None);
self.transmit_data(error.to_string().as_str());
},
} }
self.stream.set_read_timeout(None).expect("set_read_timeout call failed");
self.stream.set_nonblocking(true).expect("set_nonblocking call failed");
} }
#[deprecated(since="24.7.20", note="will be removed in future, please do not use!")] #[deprecated(since="24.7.20", note="will be removed in future, please do not use!")]

1
src/server/commands/mod.rs
View File

@ -206,6 +206,7 @@ impl ToString for Commands {
impl From<&str> for Commands { impl From<&str> for Commands {
fn from(data: &str) -> Self { fn from(data: &str) -> Self {
println!("HERE!!! {}", data);
let regex = Regex::new(r###"(\?|!)([a-zA-z0-9]*):|([a-zA-z]*):([a-zA-Z0-9\-\+\[\]{}_=/]+|("(.*?)")+)"###).unwrap(); 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 mut iter = regex.find_iter(data);
let command = iter.next().unwrap().as_str(); let command = iter.next().unwrap().as_str();

127
src/server/server_profile.rs
View File

@ -9,6 +9,7 @@ use std::sync::{Arc, Mutex};
use crossbeam_channel::Sender; use crossbeam_channel::Sender;
use parking_lot::FairMutex; use parking_lot::FairMutex;
use std::collections::HashMap; use std::collections::HashMap;
use std::io::Error;
use dashmap::DashMap; use dashmap::DashMap;
use std::io::prelude::*; use std::io::prelude::*;
use regex::Regex; use regex::Regex;
@ -47,7 +48,6 @@ impl<'z> Server<'z> {
pub fn start(&'static self) { pub fn start(&'static self) {
let listener = TcpListener::bind(self.get_address()).unwrap(); let listener = TcpListener::bind(self.get_address()).unwrap();
let mut buffer = [0; 1024];
loop { loop {
if let Ok((mut stream, addr)) = listener.accept() { if let Ok((mut stream, addr)) = listener.accept() {
@ -56,45 +56,48 @@ impl<'z> Server<'z> {
let request = Commands::Request(None); let request = Commands::Request(None);
self.transmit_data(&stream, &request.to_string().as_str()); self.transmit_data(&stream, &request.to_string().as_str());
stream.read(&mut buffer).unwrap();
let command = Commands::from(&buffer);
match command {
Commands::Connect(Some(data)) => {
let uuid = data.get("uuid").unwrap();
let username = data.get("name").unwrap();
let address = data.get("host").unwrap();
let stream = Arc::new(stream); match self.read_data(&stream) {
let mut client = Client::new(self, stream, &uuid, &username, &address); Ok(command) => {
match command {
let tx = client.get_transmitter(); Commands::Connect(Some(data)) => {
let uuid = data.get("uuid").unwrap();
let username = data.get("name").unwrap();
let address = data.get("host").unwrap();
let mut clients_hashmap = self.connected_clients.lock().unwrap(); let stream = Arc::new(stream);
clients_hashmap.insert(uuid.to_string(), tx.clone()); let mut client = Client::new(self, stream, &uuid, &username, &address);
std::mem::drop(clients_hashmap);
let tx = client.get_transmitter();
let success = Commands::Success(None);
tx.send(success).unwrap();
self.thread_pool.execute(move || { let mut clients_hashmap = self.connected_clients.lock().unwrap();
client.handle_connection(); clients_hashmap.insert(uuid.to_string(), tx.clone());
}); std::mem::drop(clients_hashmap);
let params: HashMap<String, String> = [(String::from("name"), username.clone()), (String::from("host"), address.clone()), (String::from("uuid"), uuid.clone())].iter().cloned().collect(); let success = Commands::Success(None);
let new_client = Commands::Client(Some(params)); tx.send(success).unwrap();
self.update_all_clients(uuid.as_str(), new_client);
}, self.thread_pool.execute(move || {
Commands::Info(None) => { client.handle_connection();
let params: HashMap<String, String> = [(String::from("name"), self.name.to_string().clone()), (String::from("owner"), self.author.to_string().clone())].iter().cloned().collect(); });
let command = Commands::Success(Some(params));
let params: HashMap<String, String> = [(String::from("name"), username.clone()), (String::from("host"), address.clone()), (String::from("uuid"), uuid.clone())].iter().cloned().collect();
self.transmit_data(&stream, command.to_string().as_str()); let new_client = Commands::Client(Some(params));
}, self.update_all_clients(uuid.as_str(), new_client);
_ => { },
println!("Invalid command!"); Commands::Info(None) => {
self.transmit_data(&stream, Commands::Error(None).to_string().as_str()); let params: HashMap<String, String> = [(String::from("name"), self.name.to_string().clone()), (String::from("owner"), self.author.to_string().clone())].iter().cloned().collect();
let command = Commands::Success(Some(params));
self.transmit_data(&stream, command.to_string().as_str());
},
_ => {
println!("Invalid command!");
self.transmit_data(&stream, Commands::Error(None).to_string().as_str());
},
}
}, },
Err(_) => println!("ERROR: stream closed"),
} }
} }
} }
@ -109,8 +112,8 @@ impl<'z> Server<'z> {
pub fn update_all_clients(&self, uuid: &str, command: Commands){ pub fn update_all_clients(&self, uuid: &str, command: Commands){
let clients = self.connected_clients.lock().unwrap(); let clients = self.connected_clients.lock().unwrap();
if clients.len() > 1 { for (client_uuid, tx) in clients.iter() {
for tx in clients.values(){ if uuid != client_uuid.to_string() {
tx.send(command.clone()).unwrap(); tx.send(command.clone()).unwrap();
} }
} }
@ -134,6 +137,15 @@ impl<'z> Server<'z> {
stream.flush().unwrap(); stream.flush().unwrap();
} }
fn read_data(&self, mut stream: &TcpStream) -> Result<Commands, Error> {
let mut buffer = [0; 1024];
stream.read(&mut buffer)?;
let command = Commands::from(&buffer);
Ok(command)
}
#[deprecated(since="24.7.20", note="will be removed in future, please do not use!")] #[deprecated(since="24.7.20", note="will be removed in future, please do not use!")]
#[allow(dead_code)] #[allow(dead_code)]
pub fn get_info(&self, tx: Sender<Commands>) { pub fn get_info(&self, tx: Sender<Commands>) {
@ -222,6 +234,11 @@ mod tests{
} }
} }
fn force_disconnect(mut stream: &TcpStream){
let msg = "!disconnect:";
transmit_data(&stream, msg);
}
#[test] #[test]
fn test_server_connect(){ fn test_server_connect(){
let mut buffer = [0; 1024]; let mut buffer = [0; 1024];
@ -245,6 +262,9 @@ mod tests{
let msg = b"!disconnect:"; let msg = b"!disconnect:";
stream.write(msg).unwrap(); stream.write(msg).unwrap();
let dur = time::Duration::from_millis(500);
thread::sleep(dur);
} }
#[test] #[test]
@ -255,19 +275,17 @@ mod tests{
let mut stream = TcpStream::connect("0.0.0.0:6000").unwrap(); let mut stream = TcpStream::connect("0.0.0.0:6000").unwrap();
stream.read(&mut buffer).unwrap(); let command = read_data(&stream);
let mut command = Commands::from(&buffer);
assert_eq!(command, Commands::Request(None)); assert_eq!(command, Commands::Request(None));
let msg = b"!info:"; let msg = "!info:";
stream.write(msg).unwrap(); transmit_data(&stream, msg);
stream.read(&mut buffer).unwrap(); let command = read_data(&stream);
command = Commands::from(&buffer);
let params: HashMap<String, String> = [(String::from("name"), String::from("test")), (String::from("owner"), String::from("test"))].iter().cloned().collect(); let params: HashMap<String, String> = [(String::from("name"), String::from("test")), (String::from("owner"), String::from("test"))].iter().cloned().collect();
assert_eq!(command, Commands::Success(Some(params))); assert_eq!(command, Commands::Success(Some(params)));
} }
#[test] #[test]
@ -286,6 +304,9 @@ mod tests{
let msg = "!disconnect:"; let msg = "!disconnect:";
transmit_data(&stream, msg); transmit_data(&stream, msg);
let dur = time::Duration::from_millis(500);
thread::sleep(dur);
} }
#[test] #[test]
@ -301,11 +322,11 @@ mod tests{
assert_eq!(command, Commands::Success(None)); assert_eq!(command, Commands::Success(None));
let msg = "!disconnect"; let msg = "!disconnect:";
transmit_data(&stream, msg); transmit_data(&stream, msg);
//let dur = time::Duration::from_millis(1000); let dur = time::Duration::from_millis(500);
//thread::sleep(dur); thread::sleep(dur);
} }
@ -398,8 +419,8 @@ mod tests{
transmit_data(&stream_three, msg); transmit_data(&stream_three, msg);
transmit_data(&stream_four, msg); transmit_data(&stream_four, msg);
//let dur = time::Duration::from_millis(1000); let dur = time::Duration::from_millis(500);
//thread::sleep(dur); thread::sleep(dur);
} }
#[test] #[test]
@ -438,6 +459,9 @@ mod tests{
let msg = "!disconnect:"; let msg = "!disconnect:";
transmit_data(&stream_one, msg); transmit_data(&stream_one, msg);
transmit_data(&stream_two, msg); transmit_data(&stream_two, msg);
let dur = time::Duration::from_millis(500);
thread::sleep(dur);
} }
#[test] #[test]
@ -474,5 +498,8 @@ mod tests{
let msg = "!disconnect:"; let msg = "!disconnect:";
transmit_data(&stream_one, msg); transmit_data(&stream_one, msg);
let dur = time::Duration::from_millis(500);
thread::sleep(dur);
} }
} }