rustyphoenixrequest 1.6.0

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

use std::{
	io::{BufReader, prelude::*},
	net::{TcpListener, TcpStream},
};

use crate::pmimetype::get_content_type;

use crate::phoenix_request::{
	PRequestParam,
	PResponseParam,
	PhoenixRequestStream,
	PhoenixRequestServer,
};

///Stream of the TCP connection
pub struct PTcpRequestStream{
	///Stream of tcp input
	stream: TcpStream
}

impl PhoenixRequestStream for PTcpRequestStream{
	///Recieved a request from a client
	/// # Parameters
	/// - `request` : PRequestParam recievred from the client
	/// # Returns
	/// true if a request has been recieved false otherwise
	fn recv_request(&mut self, request: &mut PRequestParam) -> bool {
		let buf_reader = BufReader::new(&self.stream);
		//We get an Option, so we have to nicely deal with error
		let request_line = match buf_reader.lines().next() {
			Some(buffer_next) => match buffer_next {
				Ok(value) => value,
				Err(err) => panic!("PTcpRequestStream::recv_request error while getting request : {}", err)
			},
			None => return false,	//Sometime we have a None because why not (some sort of timeout of the TcpStream or TcpListener)
		};
		let list_param = request_line.split(' ');
		if list_param.clone().count() >= 3 {
			request.set_command(&String::from(list_param.clone().next().unwrap()));
			request.set_url(&String::from(list_param.clone().skip(1).next().unwrap()));
			request.set_protocol(&String::from(list_param.clone().skip(2).next().unwrap()));
			return true;
		}
		return false;
	}

	///Send response to the client
	/// # Parameters
	/// - `response` : PResponseParam to be sent to the client
	fn send_response(&mut self, response: &PResponseParam){
		let length = response.content.len();
		let response = format!("{}\n{}\r\nContent-Length: {}\r\n\r\n{}", response.status, get_content_type(&response.mimetype), length, response.content);
// 		println!("response = '{}'", response);
		self.stream.write_all(response.as_bytes()).unwrap();
	}
}

///Request server with a TcpListener
pub struct PTcpRequestServer{
	///Listener of the tcp socket
	listener: TcpListener,
}

impl PhoenixRequestServer for PTcpRequestServer {
	type Stream = PTcpRequestStream;
	///Initialise the Request server
	/// # Parameters
	/// - `hostname` : address of the server
	/// - `port` : port of the server
	/// # Returns
	/// initialised Request server
	fn new(hostname: &String, port: u16) -> Self{
		let server_address = format!("{}:{}", hostname, port);
		PTcpRequestServer{
			listener: TcpListener::bind(&server_address).unwrap()
		}
	}
	///Accept the connection and get a corresponding stream
	/// # Returns
	/// corresponding stream
	fn accept(&self) -> Self::Stream{
		PTcpRequestStream{
			stream: match self.listener.accept() {
				Ok(s) => s.0,	//The horrible syntaxe to get the first element of a tuple
				Err(error) => panic!("PTcpRequestServer::accept error : {}", error)
			}
		}
	}
}

/*
#[cfg(test)]
mod tests {
//{We need the previously defined functions of the crate :
	use super::*;

	use crate::phoenix_generic_request_server::{
		PRequestMode,
		PGenericRequestStream,
		PGenericRequestServer,
	};
	use crate::phoenix_empty_request_server::{
		PEmptyRequestStream,
		PEmptyRequestServer
	};

	#[test]
	fn test_tcp_generic_request(){
		let mut server: PGenericRequestServer<PTcpRequestServer, PEmptyRequestServer> = PGenericRequestServer::new(&String::from("127.0.0.1"), 8080, PRequestMode::Mock);
		let mut stream: PGenericRequestStream<PTcpRequestStream, PEmptyRequestStream> = server.accept();

		let mut request: PRequestParam = Default::default();
		assert_eq!(stream.recv_request(&mut request), false);
		assert_eq!(stream.get_mode(), PRequestMode::Mock);
		let response = PResponseParam{status: String::from("HTTP/1.1 200 OK"), content: String::from("some html page")};
		stream.send_response(&response);
	}
}*/