Skip to content

Commit 1b58dde

Browse files
illegalprimeillegalprime
committed
Updated all examples with new API.
1 parent f89ab46 commit 1b58dde

File tree

5 files changed

+67
-75
lines changed

5 files changed

+67
-75
lines changed

‎Cargo.toml‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -24,16 +24,13 @@ bitflags = "^0.8"
2424
rand = "^0.3"
2525
byteorder = "^1.0"
2626
sha1 = "^0.2"
27+
base64 = "^0.5"
2728
futures = { version = "^0.1", optional = true }
2829
tokio-core = { version = "0.1.7", optional = true }
2930
tokio-io = { version = "0.1.1", optional = true }
3031
tokio-tls = { version = "^0.1", optional = true }
3132
bytes = { version = "^0.4", optional = true }
3233
native-tls = { version = "^0.1.2", optional = true }
33-
base64 = "^0.5"
34-
35-
[dev-dependencies]
36-
serde_json = "^1.0"
3734

3835
[replace."tokio-io:0.1.1"]
3936
git = "https://github.com/illegalprime/tokio-io.git"

‎examples/autobahn-client.rs‎

Lines changed: 23 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,8 @@
11
extern crate websocket;
2-
extern crate serde_json;
32

4-
use std::str::from_utf8;
53
use websocket::ClientBuilder;
4+
use websocket::OwnedMessage;
65
use websocket::Message;
7-
use websocket::message::Type;
86

97
fn main() {
108
let addr = "ws://127.0.0.1:9001".to_string();
@@ -33,7 +31,7 @@ fn main() {
3331
println!("Executing test case: {}/{}", case_id, case_count);
3432

3533
for message in receiver.incoming_messages() {
36-
let message: Message = match message {
34+
let message = match message {
3735
Ok(message) => message,
3836
Err(e) => {
3937
println!("Error: {:?}", e);
@@ -42,20 +40,19 @@ fn main() {
4240
}
4341
};
4442

45-
match message.opcode {
46-
Type::Text => {
47-
let response = Message::text(from_utf8(&*message.payload).unwrap());
48-
sender.send_message(&response).unwrap();
43+
match message {
44+
OwnedMessage::Text(txt) => {
45+
sender.send_message(&OwnedMessage::Text(txt)).unwrap();
4946
}
50-
Type::Binary => {
51-
sender.send_message(&Message::binary(message.payload)).unwrap();
47+
OwnedMessage::Binary(bin) => {
48+
sender.send_message(&OwnedMessage::Binary(bin)).unwrap();
5249
}
53-
Type::Close => {
54-
let _ = sender.send_message(&Message::close());
50+
OwnedMessage::Close(_) => {
51+
let _ = sender.send_message(&OwnedMessage::Close(None));
5552
break;
5653
}
57-
Type::Ping => {
58-
sender.send_message(&Message::pong(message.payload)).unwrap();
54+
OwnedMessage::Ping(data) => {
55+
sender.send_message(&OwnedMessage::Pong(data)).unwrap();
5956
}
6057
_ => (),
6158
}
@@ -81,7 +78,7 @@ fn get_case_count(addr: String) -> usize {
8178
let mut count = 0;
8279

8380
for message in receiver.incoming_messages() {
84-
let message: Message = match message {
81+
let message = match message {
8582
Ok(message) => message,
8683
Err(e) => {
8784
println!("Error: {:?}", e);
@@ -90,17 +87,17 @@ fn get_case_count(addr: String) -> usize {
9087
break;
9188
}
9289
};
93-
match message.opcode {
94-
Type::Text => {
95-
count = serde_json::from_str(from_utf8(&*message.payload).unwrap()).unwrap();
90+
match message {
91+
OwnedMessage::Text(txt) => {
92+
count = txt.parse().unwrap();
9693
println!("Will run {} cases...", count);
9794
}
98-
Type::Close => {
95+
OwnedMessage::Close(_) => {
9996
let _ = sender.send_message(&Message::close());
10097
break;
10198
}
102-
Type::Ping => {
103-
sender.send_message(&Message::pong(message.payload)).unwrap();
99+
OwnedMessage::Ping(data) => {
100+
sender.send_message(&OwnedMessage::Pong(data)).unwrap();
104101
}
105102
_ => (),
106103
}
@@ -125,23 +122,23 @@ fn update_reports(addr: String, agent: &str) {
125122
println!("Updating reports...");
126123

127124
for message in receiver.incoming_messages() {
128-
let message: Message = match message {
125+
let message = match message {
129126
Ok(message) => message,
130127
Err(e) => {
131128
println!("Error: {:?}", e);
132129
let _ = sender.send_message(&Message::close());
133130
return;
134131
}
135132
};
136-
match message.opcode {
137-
Type::Close => {
133+
match message {
134+
OwnedMessage::Close(_) => {
138135
let _ = sender.send_message(&Message::close());
139136
println!("Reports updated.");
140137
println!("Test suite finished!");
141138
return;
142139
}
143-
Type::Ping => {
144-
sender.send_message(&Message::pong(message.payload)).unwrap();
140+
OwnedMessage::Ping(data) => {
141+
sender.send_message(&OwnedMessage::Pong(data)).unwrap();
145142
}
146143
_ => (),
147144
}

‎examples/autobahn-server.rs‎

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,7 @@
11
extern crate websocket;
22

33
use std::thread;
4-
use std::str::from_utf8;
5-
use websocket::{Server, Message};
6-
use websocket::message::Type;
4+
use websocket::{Server, Message, OwnedMessage};
75

86
fn main() {
97
let server = Server::bind("127.0.0.1:9002").unwrap();
@@ -16,7 +14,7 @@ fn main() {
1614
let (mut receiver, mut sender) = client.split().unwrap();
1715

1816
for message in receiver.incoming_messages() {
19-
let message: Message = match message {
17+
let message = match message {
2018
Ok(message) => message,
2119
Err(e) => {
2220
println!("{:?}", e);
@@ -25,21 +23,19 @@ fn main() {
2523
}
2624
};
2725

28-
match message.opcode {
29-
Type::Text => {
30-
let response = Message::text(from_utf8(&*message.payload).unwrap());
31-
sender.send_message(&response).unwrap()
26+
match message {
27+
OwnedMessage::Text(txt) => {
28+
sender.send_message(&OwnedMessage::Text(txt)).unwrap()
3229
}
33-
Type::Binary => {
34-
sender.send_message(&Message::binary(message.payload)).unwrap()
30+
OwnedMessage::Binary(bin) => {
31+
sender.send_message(&OwnedMessage::Binary(bin)).unwrap()
3532
}
36-
Type::Close => {
37-
let _ = sender.send_message(&Message::close());
33+
OwnedMessage::Close(_) => {
34+
sender.send_message(&OwnedMessage::Close(None)).ok();
3835
return;
3936
}
40-
Type::Ping => {
41-
let message = Message::pong(message.payload);
42-
sender.send_message(&message).unwrap();
37+
OwnedMessage::Ping(data) => {
38+
sender.send_message(&OwnedMessage::Pong(data)).unwrap();
4339
}
4440
_ => (),
4541
}

‎examples/client.rs‎

Lines changed: 25 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
11
extern crate websocket;
22

3+
use std::thread;
4+
use std::sync::mpsc::channel;
5+
use std::io::stdin;
6+
7+
use websocket::{Message, OwnedMessage};
8+
use websocket::client::ClientBuilder;
9+
310
const CONNECTION: &'static str = "ws://127.0.0.1:2794";
411

512
fn main() {
6-
use std::thread;
7-
use std::sync::mpsc::channel;
8-
use std::io::stdin;
9-
10-
use websocket::Message;
11-
use websocket::message::Type;
12-
use websocket::client::ClientBuilder;
1313

1414
println!("Connecting to {}", CONNECTION);
1515

@@ -30,17 +30,20 @@ fn main() {
3030
let send_loop = thread::spawn(move || {
3131
loop {
3232
// Send loop
33-
let message: Message = match rx.recv() {
33+
let message = match rx.recv() {
3434
Ok(m) => m,
3535
Err(e) => {
3636
println!("Send Loop: {:?}", e);
3737
return;
3838
}
3939
};
40-
if Type::Close == message.opcode {
41-
let _ = sender.send_message(&message);
42-
// If it's a close message, just send it and then return.
43-
return;
40+
match message {
41+
OwnedMessage::Close(_) => {
42+
let _ = sender.send_message(&message);
43+
// If it's a close message, just send it and then return.
44+
return;
45+
}
46+
_ => (),
4447
}
4548
// Send the message
4649
match sender.send_message(&message) {
@@ -57,22 +60,22 @@ fn main() {
5760
let receive_loop = thread::spawn(move || {
5861
// Receive loop
5962
for message in receiver.incoming_messages() {
60-
let message: Message = match message {
63+
let message = match message {
6164
Ok(m) => m,
6265
Err(e) => {
6366
println!("Receive Loop: {:?}", e);
64-
let _ = tx_1.send(Message::close());
67+
let _ = tx_1.send(OwnedMessage::Close(None));
6568
return;
6669
}
6770
};
68-
match message.opcode {
69-
Type::Close => {
71+
match message {
72+
OwnedMessage::Close(_) => {
7073
// Got a close message, so send a close message and return
71-
let _ = tx_1.send(Message::close());
74+
let _ = tx_1.send(OwnedMessage::Close(None));
7275
return;
7376
}
74-
Type::Ping => {
75-
match tx_1.send(Message::pong(message.payload)) {
77+
OwnedMessage::Ping(data) => {
78+
match tx_1.send(OwnedMessage::Pong(data)) {
7679
// Send a pong in response
7780
Ok(()) => (),
7881
Err(e) => {
@@ -97,13 +100,13 @@ fn main() {
97100
let message = match trimmed {
98101
"/close" => {
99102
// Close the connection
100-
let _ = tx.send(Message::close());
103+
let _ = tx.send(OwnedMessage::Close(None));
101104
break;
102105
}
103106
// Send a ping
104-
"/ping" => Message::ping(b"PING".to_vec()),
107+
"/ping" => OwnedMessage::Ping(b"PING".to_vec()),
105108
// Otherwise, just send text
106-
_ => Message::text(trimmed.to_string()),
109+
_ => OwnedMessage::Text(trimmed.to_string()),
107110
};
108111

109112
match tx.send(message) {

‎examples/hyper.rs‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,7 @@ extern crate hyper;
33

44
use std::thread;
55
use std::io::Write;
6-
use websocket::{Server, Message};
7-
use websocket::message::Type;
6+
use websocket::{Server, Message, OwnedMessage};
87
use hyper::Server as HttpServer;
98
use hyper::net::Fresh;
109
use hyper::server::request::Request;
@@ -44,23 +43,23 @@ fn main() {
4443

4544
println!("Connection from {}", ip);
4645

47-
let message = Message::text("Hello".to_string());
46+
let message = Message::text("Hello");
4847
client.send_message(&message).unwrap();
4948

5049
let (mut receiver, mut sender) = client.split().unwrap();
5150

5251
for message in receiver.incoming_messages() {
53-
let message: Message = message.unwrap();
52+
let message = message.unwrap();
5453

55-
match message.opcode {
56-
Type::Close => {
54+
match message {
55+
OwnedMessage::Close(_) => {
5756
let message = Message::close();
5857
sender.send_message(&message).unwrap();
5958
println!("Client {} disconnected", ip);
6059
return;
6160
}
62-
Type::Ping => {
63-
let message = Message::pong(message.payload);
61+
OwnedMessage::Ping(data) => {
62+
let message = Message::pong(data);
6463
sender.send_message(&message).unwrap();
6564
}
6665
_ => sender.send_message(&message).unwrap(),

0 commit comments

Comments
 (0)