1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
use mio::deprecated::{EventLoop, Handler, Sender};
use serde_json;
use mio::channel;
use std::thread;
use std;
use std::vec::{Vec};
use messages;
use messages::{Message, IncomingMessage, Shutdown, Internal, Host, Client, ServerInfo, ClaimDevice};
use config::{Config};
use local_server;
use local_server::{LocalServer};
use websocket_server;
use devices::{DeviceManager};
use ws;
pub fn start_server(config: Config,
local_server_loop: Option<EventLoop<LocalServer>>,
local_server_test_tx: Option<std::sync::mpsc::Sender<Message>>) {
let mut event_loop = EventLoop::new().expect("Failed to create event loop");
let mut server = ButtplugServer::new(config,
local_server_loop,
local_server_test_tx,
event_loop.channel());
event_loop.run(&mut server).expect("Failed to start event loop");
}
pub struct ButtplugServer {
threads: Vec<thread::JoinHandle<()>>,
websocket_sender: Option<ws::Sender>,
tx: Sender<IncomingMessage>,
device_manager: DeviceManager,
}
impl ButtplugServer {
pub fn new(config: Config,
local_server_loop: Option<EventLoop<LocalServer>>,
local_server_test_tx: Option<std::sync::mpsc::Sender<Message>>,
tx: Sender<IncomingMessage>) -> ButtplugServer {
let mut server_threads = vec![];
let mut sender = None;
if let Some(_) = config.network_address {
info!("Starting network server");
}
if let Some(wsaddr) = config.websocket_address {
info!("Starting websocket server");
let ws = websocket_server::start_server(tx.clone(), wsaddr);
server_threads.push(ws.thread);
sender = Some(ws.sender);
}
if let Some(local_server_loop) = local_server_loop {
let unwrapped_local_server_test_tx = match local_server_test_tx {
Some(m) => m,
None => panic!("Require tx with local server loop!")
};
info!("Starting local server");
let server_tx = tx.clone();
server_threads.push(thread::spawn(move|| {
local_server::start_server(server_tx, unwrapped_local_server_test_tx, local_server_loop);
}));
}
println!("{}", serde_json::to_string(&ServerInfo::as_message("Testing".to_string())).unwrap());
println!("{}", serde_json::to_string(&ClaimDevice::as_message(1)).unwrap());
ButtplugServer {
threads: server_threads,
tx: tx,
websocket_sender: sender,
device_manager: DeviceManager::new()
}
}
fn shutdown(&mut self) {
if let Some(ref ws) = self.websocket_sender {
ws.shutdown();
}
let ts = self.threads.drain(..);
for t in ts {
t.join().expect("Could not join thread!");
}
}
}
impl Handler for ButtplugServer {
type Timeout = usize;
type Message = IncomingMessage;
fn notify(&mut self, _reactor: &mut EventLoop<ButtplugServer>, msg: IncomingMessage) {
match msg.msg {
Message::Internal(m) => {
match m {
Internal::Shutdown(_) => {
self.shutdown();
_reactor.shutdown();
}
}
},
Message::Client(m) => {
match m {
Client::RequestServerInfo(_) => {
let s = messages::ServerInfo::as_message("Buttplug v0.0.1".to_string());
(msg.callback)(s);
}
_ => {
warn!("Don't know what to do with this client message!");
}
}
},
Message::Device(_, _) => {
info!("Got device message!");
self.device_manager.handle_message(msg);
},
_ => {
warn!("Don't know how to handle this host message!");
}
};
}
}