From e64240b124130f7d728107b2a7d5d6dfa886691b Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Fri, 26 Feb 2016 13:15:49 +0100 Subject: [PATCH] Connect Controller to Client. --- src/client.rs | 47 ++++++++++++++++++++++++++--------------------- src/control.rs | 19 +++++++++++++------ src/handler.rs | 3 +-- src/main.rs | 21 ++++++++++++++++++--- src/proto/mod.rs | 10 ++++++++++ 5 files changed, 68 insertions(+), 32 deletions(-) diff --git a/src/client.rs b/src/client.rs index 20e9ea9..9f19376 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,20 +1,12 @@ -use std::sync::mpsc::Receiver; +use std::sync::mpsc; -use mio::Sender; +use mio; use config; +use control::{ControlRequest, ControlResponse}; +use proto::{Request, Response}; use proto::server::*; -#[derive(Debug)] -pub enum Request { - ServerRequest(ServerRequest), -} - -#[derive(Debug)] -pub enum Response { - ServerResponse(ServerResponse), -} - #[derive(Debug, Clone, Copy)] enum State { NotLoggedIn, @@ -24,16 +16,28 @@ enum State { pub struct Client { state: State, - tx: Sender, - rx: Receiver, + + proto_tx: mio::Sender, + proto_rx: mpsc::Receiver, + + control_tx: mpsc::Sender, + control_rx: mpsc::Receiver, } impl Client { - pub fn new(tx: Sender, rx: Receiver) -> Self { + pub fn new( + proto_tx: mio::Sender, + proto_rx: mpsc::Receiver, + control_tx: mpsc::Sender, + control_rx: mpsc::Receiver) + -> Self + { Client { state: State::NotLoggedIn, - tx: tx, - rx: rx, + proto_tx: proto_tx, + proto_rx: proto_rx, + control_tx: control_tx, + control_rx: control_rx, } } @@ -46,10 +50,10 @@ impl Client { config::VER_MAJOR, config::VER_MINOR, ).unwrap()); - self.tx.send(Request::ServerRequest(server_request)).unwrap(); + self.proto_tx.send(Request::ServerRequest(server_request)).unwrap(); loop { - let response = match self.rx.recv() { + let response = match self.proto_rx.recv() { Ok(response) => response, Err(e) => { error!("Error receiving response: {}", e); @@ -57,8 +61,9 @@ impl Client { }, }; match response { - Response::ServerResponse(server_response) => - self.handle_server_response(server_response), + Response::ServerResponse(server_response) => { + self.handle_server_response(server_response); + }, } } } diff --git a/src/control.rs b/src/control.rs index 93034fc..984d423 100644 --- a/src/control.rs +++ b/src/control.rs @@ -41,6 +41,7 @@ impl Controller { let port = config::CONTROL_PORT; loop { let client = Self::get_client(host, port); + info!("Controller client connected"); let (mut sender, mut receiver) = client.split(); let tx = self.client_tx.clone(); thread::spawn(move || { @@ -53,6 +54,7 @@ impl Controller { fn get_client(host: &str, port: u16) -> WebSocketClient { let mut server = websocket::Server::bind((host, port)).unwrap(); + info!("Controller bound to {}:{}", host, port); loop { match Self::try_get_client(&mut server) { Ok(client) => return client, @@ -92,8 +94,13 @@ impl Controller { continue; }, }; - let control_request = json::decode(&payload).unwrap(); - tx.send(control_request); + match json::decode(&payload) { + Ok(control_request) => { + debug!("Received control request: {:?}", control_request); + tx.send(control_request); + }, + Err(e) => warn!("Error decoding control request: {}", e), + }; } } @@ -108,23 +115,23 @@ impl Controller { } } -#[derive(RustcDecodable, RustcEncodable)] +#[derive(Debug, RustcDecodable, RustcEncodable)] pub enum ControlRequest { LoginRequest(LoginRequest), } -#[derive(RustcDecodable, RustcEncodable)] +#[derive(Debug, RustcDecodable, RustcEncodable)] pub enum ControlResponse { LoginResponse(LoginResponse), } -#[derive(RustcDecodable, RustcEncodable)] +#[derive(Debug, RustcDecodable, RustcEncodable)] pub struct LoginRequest { username: String, password: String, } -#[derive(RustcDecodable, RustcEncodable)] +#[derive(Debug, RustcDecodable, RustcEncodable)] pub enum LoginResponse { LoginOk { motd: String, diff --git a/src/handler.rs b/src/handler.rs index b0855e6..c821656 100644 --- a/src/handler.rs +++ b/src/handler.rs @@ -5,8 +5,7 @@ use std::sync::mpsc::Sender; use mio::{EventLoop, EventSet, Handler, PollOpt, Token}; use mio::tcp::TcpStream; -use client::{Request, Response}; -use proto::{Packet, PacketStream}; +use proto::{Packet, PacketStream, Request, Response}; use proto::server::*; struct TokenCounter { diff --git a/src/main.rs b/src/main.rs index 2f12007..5e407d3 100644 --- a/src/main.rs +++ b/src/main.rs @@ -21,6 +21,7 @@ use mio::EventLoop; use mio::tcp::TcpStream; use client::Client; +use control::Controller; use handler::ConnectionHandler; fn connect(hostname: &str, port: u16) -> io::Result { @@ -43,14 +44,28 @@ fn main() { let mut event_loop = EventLoop::new().unwrap(); - let (tx, rx) = channel(); + let (handler_to_client_tx, handler_to_client_rx) = channel(); - let mut handler = ConnectionHandler::new(stream, tx, &mut event_loop); + let mut handler = + ConnectionHandler::new(stream, handler_to_client_tx, &mut event_loop); - let mut client = Client::new(event_loop.channel(), rx); + let (control_to_client_tx, control_to_client_rx) = channel(); + let (client_to_control_tx, client_to_control_rx) = channel(); + let client_to_handler_tx = event_loop.channel(); + + let mut client = Client::new( + client_to_handler_tx, handler_to_client_rx, + client_to_control_tx, control_to_client_rx); thread::spawn(move || { client.run(); }); + let mut controller = + Controller::new(control_to_client_tx, client_to_control_rx); + thread::spawn(move || { + controller.run(); + }); + + event_loop.run(&mut handler).unwrap(); } diff --git a/src/proto/mod.rs b/src/proto/mod.rs index 8700ca3..3dad6e6 100644 --- a/src/proto/mod.rs +++ b/src/proto/mod.rs @@ -2,3 +2,13 @@ mod packet; pub mod server; pub use self::packet::{PacketStream, Packet}; + +use self::server::{ServerRequest, ServerResponse}; + +pub enum Request { + ServerRequest(ServerRequest), +} + +pub enum Response { + ServerResponse(ServerResponse), +}