You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
144 lines
4.1 KiB
144 lines
4.1 KiB
use std::io;
|
|
use std::io::{Read, Write};
|
|
use std::sync::mpsc;
|
|
use std::thread;
|
|
|
|
use rustc_serialize::json;
|
|
use mio::tcp::TcpStream;
|
|
use websocket;
|
|
use websocket::{Receiver, Sender};
|
|
|
|
use client;
|
|
use config;
|
|
|
|
type WebSocketReceiver =
|
|
websocket::receiver::Receiver<websocket::WebSocketStream>;
|
|
|
|
type WebSocketSender =
|
|
websocket::sender::Sender<websocket::WebSocketStream>;
|
|
|
|
type WebSocketClient =
|
|
websocket::Client<websocket::DataFrame, WebSocketSender, WebSocketReceiver>;
|
|
|
|
pub struct Controller {
|
|
client_tx: mpsc::Sender<client::IncomingMessage>,
|
|
client_rx: mpsc::Receiver<ControlResponse>,
|
|
}
|
|
|
|
impl Controller {
|
|
pub fn new(tx: mpsc::Sender<client::IncomingMessage>,
|
|
rx: mpsc::Receiver<ControlResponse>)
|
|
-> Self
|
|
{
|
|
Controller {
|
|
client_tx: tx,
|
|
client_rx: rx,
|
|
}
|
|
}
|
|
|
|
pub fn run(&mut self) {
|
|
let host = config::CONTROL_HOST;
|
|
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 || {
|
|
Self::receiver_loop(receiver, tx);
|
|
});
|
|
Self::sender_loop(sender, &mut self.client_rx);
|
|
}
|
|
}
|
|
|
|
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,
|
|
Err(e) => error!("Error accepting control connection: {}", e),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn try_get_client(server: &mut websocket::Server)
|
|
-> io::Result<WebSocketClient>
|
|
{
|
|
let connection = try!(server.accept());
|
|
let request = try!(connection.read_request());
|
|
match request.accept().send() {
|
|
Ok(client) => Ok(client),
|
|
Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
|
|
}
|
|
}
|
|
|
|
fn receiver_loop(
|
|
mut receiver: WebSocketReceiver,
|
|
tx: mpsc::Sender<client::IncomingMessage>)
|
|
{
|
|
for message_result in receiver.incoming_messages() {
|
|
let message: websocket::Message = match message_result {
|
|
Ok(message) => message,
|
|
Err(e) => {
|
|
warn!("Error receiving control message {}", e);
|
|
continue;
|
|
},
|
|
};
|
|
let payload = match message.opcode {
|
|
websocket::message::Type::Text =>
|
|
String::from_utf8(message.payload.into_owned()).unwrap(),
|
|
|
|
code => {
|
|
warn!("Unhandled websocket message type: {:?}", code);
|
|
continue;
|
|
},
|
|
};
|
|
match json::decode(&payload) {
|
|
Ok(control_request) => {
|
|
debug!("Received control request: {:?}", control_request);
|
|
tx.send(client::IncomingMessage::ControlRequest(
|
|
control_request));
|
|
},
|
|
Err(e) => warn!("Error decoding control request: {}", e),
|
|
};
|
|
}
|
|
}
|
|
|
|
fn sender_loop(
|
|
mut sender: WebSocketSender, rx: &mut mpsc::Receiver<ControlResponse>)
|
|
{
|
|
for control_response in rx.iter() {
|
|
let encoded = json::encode(&control_response).unwrap();
|
|
let message = websocket::Message::text(encoded);
|
|
sender.send_message(&message).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, RustcDecodable, RustcEncodable)]
|
|
pub enum ControlRequest {
|
|
LoginRequest(LoginRequest),
|
|
}
|
|
|
|
#[derive(Debug, RustcDecodable, RustcEncodable)]
|
|
pub enum ControlResponse {
|
|
LoginResponse(LoginResponse),
|
|
}
|
|
|
|
#[derive(Debug, RustcDecodable, RustcEncodable)]
|
|
pub struct LoginRequest {
|
|
username: String,
|
|
password: String,
|
|
}
|
|
|
|
#[derive(Debug, RustcDecodable, RustcEncodable)]
|
|
pub enum LoginResponse {
|
|
LoginOk {
|
|
motd: String,
|
|
},
|
|
LoginFail {
|
|
reason: String,
|
|
}
|
|
}
|