Connect Controller to Client.

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<Request>,
-    rx: Receiver<Response>,
+
+    proto_tx: mio::Sender<Request>,
+    proto_rx: mpsc::Receiver<Response>,
+
+    control_tx: mpsc::Sender<ControlResponse>,
+    control_rx: mpsc::Receiver<ControlRequest>,
 }
 
 impl Client {
-    pub fn new(tx: Sender<Request>, rx: Receiver<Response>) -> Self {
+    pub fn new(
+        proto_tx: mio::Sender<Request>,
+        proto_rx: mpsc::Receiver<Response>,
+        control_tx: mpsc::Sender<ControlResponse>,
+        control_rx: mpsc::Receiver<ControlRequest>)
+        -> 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);
+                },
             }
         }
     }

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,

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 {

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<TcpStream> {
@@ -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();
 }

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),
+}