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.
215 lines
6.0 KiB
215 lines
6.0 KiB
use std::io;
|
|
use std::sync::mpsc;
|
|
use std::str;
|
|
use std::thread;
|
|
|
|
use rustc_serialize::json;
|
|
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>;
|
|
|
|
enum Error {
|
|
IOError(io::Error),
|
|
WebSocketError(websocket::result::WebSocketError),
|
|
}
|
|
|
|
impl From<io::Error> for Error {
|
|
fn from(err: io::Error) -> Self {
|
|
Error::IOError(err)
|
|
}
|
|
}
|
|
|
|
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;
|
|
let mut server = websocket::Server::bind((host, port)).unwrap();
|
|
info!("Controller bound to {}:{}", host, port);
|
|
|
|
loop {
|
|
let client = match Self::try_get_client(&mut server) {
|
|
Ok(client) => client,
|
|
Err(e) => {
|
|
error!("Error accepting control connection: {}", e);
|
|
continue;
|
|
}
|
|
};
|
|
info!("Controller client connected");
|
|
|
|
let (sender, receiver) = client.split();
|
|
let (sender_tx, sender_rx) = mpsc::channel();
|
|
|
|
let tx = self.client_tx.clone();
|
|
let handle = thread::spawn(move || {
|
|
Self::receiver_loop(receiver, tx, sender_tx);
|
|
});
|
|
|
|
Self::sender_loop(sender, &mut self.client_rx, sender_rx);
|
|
|
|
handle.join();
|
|
}
|
|
}
|
|
|
|
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,
|
|
client_tx: mpsc::Sender<client::IncomingMessage>,
|
|
sender_tx: mpsc::Sender<()>)
|
|
{
|
|
for message_result in receiver.incoming_messages() {
|
|
let message : websocket::message::Message = match message_result {
|
|
Ok(message) => message,
|
|
Err(e) => {
|
|
warn!("Error receving websocket message: {}", e);
|
|
continue;
|
|
}
|
|
};
|
|
match message.opcode {
|
|
websocket::message::Type::Text =>
|
|
Self::handle_text_message(&message.payload, &client_tx),
|
|
|
|
websocket::message::Type::Close => break,
|
|
|
|
code => warn!("Unhandled websocket message with code {:?}",
|
|
code),
|
|
}
|
|
}
|
|
info!("Shutting down websocket receiver");
|
|
receiver.shutdown().unwrap();
|
|
// Notify sender that the websocket is closed
|
|
sender_tx.send(());
|
|
}
|
|
|
|
fn handle_text_message(
|
|
payload_bytes: &[u8],
|
|
client_tx: &mpsc::Sender<client::IncomingMessage>)
|
|
{
|
|
let payload = match str::from_utf8(payload_bytes) {
|
|
Ok(payload) => payload,
|
|
Err(e) => {
|
|
warn!("Invalid UTF8 payload: {}", e);
|
|
return;
|
|
},
|
|
};
|
|
|
|
let control_request = match json::decode(payload) {
|
|
Ok(control_request) => control_request,
|
|
Err(e) => {
|
|
warn!("Invalid JSON payload: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
|
|
let message = client::IncomingMessage::ControlRequest(control_request);
|
|
match client_tx.send(message) {
|
|
Ok(()) => (),
|
|
Err(e) => {
|
|
warn!("Error sending control request to client: {}", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn sender_loop(
|
|
mut sender: WebSocketSender,
|
|
client_rx: &mut mpsc::Receiver<ControlResponse>,
|
|
sender_rx: mpsc::Receiver<()>)
|
|
{
|
|
loop {
|
|
select! {
|
|
_ = sender_rx.recv() => break,
|
|
|
|
response_result = client_rx.recv() => {
|
|
match response_result {
|
|
Ok(response) =>
|
|
Self::send_response(&mut sender, response),
|
|
Err(e) => {
|
|
error!("Error receving from client channel: {}", e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
info!("Shutting down websocket sender");
|
|
sender.shutdown_all().unwrap();
|
|
}
|
|
|
|
fn send_response(sender: &mut WebSocketSender, response: ControlResponse) {
|
|
let message = match json::encode(&response) {
|
|
Ok(encoded) => websocket::Message::text(encoded),
|
|
Err(e) => {
|
|
error!("Error encoding control_response to JSON: {}", e);
|
|
return;
|
|
}
|
|
};
|
|
match sender.send_message(&message) {
|
|
Ok(()) => (),
|
|
Err(e) => {
|
|
error!("Error sending message to control client: {}", e);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[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,
|
|
}
|
|
}
|