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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
extern crate env_logger;
/// WebSocket server using trait objects to route
/// to an infinitely extensible number of handlers
extern crate ws;
// A WebSocket handler that routes connections to different boxed handlers by resource
struct Router {
sender: ws::Sender,
inner: Box<ws::Handler>,
}
impl ws::Handler for Router {
fn on_request(&mut self, req: &ws::Request) -> ws::Result<(ws::Response)> {
// Clone the sender so that we can move it into the child handler
let out = self.sender.clone();
match req.resource() {
"/echo" => self.inner = Box::new(Echo { ws: out }),
// Route to a data handler
"/data/one" => {
self.inner = Box::new(Data {
ws: out,
data: vec!["one", "two", "three", "four", "five"],
})
}
// Route to another data handler
"/data/two" => {
self.inner = Box::new(Data {
ws: out,
data: vec!["いち", "二", "さん", "四", "ご"],
})
}
// Use a closure as the child handler
"/closure" => {
self.inner = Box::new(move |msg: ws::Message| {
println!("Got a message on a closure handler: {}", msg);
out.close_with_reason(ws::CloseCode::Error, "Not Implemented.")
})
}
// Use the default child handler, NotFound
_ => (),
}
// Delegate to the child handler
self.inner.on_request(req)
}
// Pass through any other methods that should be delegated to the child.
//
// You could probably use a macro for this if you have many different
// routers or were building some sort of routing framework.
fn on_shutdown(&mut self) {
self.inner.on_shutdown()
}
fn on_open(&mut self, shake: ws::Handshake) -> ws::Result<()> {
self.inner.on_open(shake)
}
fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> {
self.inner.on_message(msg)
}
fn on_close(&mut self, code: ws::CloseCode, reason: &str) {
self.inner.on_close(code, reason)
}
fn on_error(&mut self, err: ws::Error) {
self.inner.on_error(err);
}
}
// This handler returns a 404 response to all handshake requests
struct NotFound;
impl ws::Handler for NotFound {
fn on_request(&mut self, req: &ws::Request) -> ws::Result<(ws::Response)> {
// This handler responds to all requests with a 404
let mut res = ws::Response::from_request(req)?;
res.set_status(404);
res.set_reason("Not Found");
Ok(res)
}
}
// This handler simply echoes all messages back to the client
struct Echo {
ws: ws::Sender,
}
impl ws::Handler for Echo {
fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> {
println!("Echo handler received a message: {}", msg);
self.ws.send(msg)
}
}
// This handler sends some data to the client and then terminates the connection on the first
// message received, presumably confirming receipt of the data
struct Data {
ws: ws::Sender,
data: Vec<&'static str>,
}
impl ws::Handler for Data {
fn on_open(&mut self, _: ws::Handshake) -> ws::Result<()> {
for msg in &self.data {
self.ws.send(*msg)?
}
Ok(())
}
fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> {
println!("Data handler received a message: {}", msg);
println!("Data handler going down.");
self.ws.close(ws::CloseCode::Normal)
}
}
fn main() {
env_logger::init();
// Listen on an address and call the closure for each connection
if let Err(error) = ws::listen("127.0.0.1:3012", |out| {
// Use our router as the handler to route the new connection
Router {
sender: out,
// Default to returning a 404 when the route doesn't match.
// You could default to any handler here.
inner: Box::new(NotFound),
}
}) {
// Inform the user of failure
println!("Failed to create WebSocket due to {:?}", error);
}
}
|
