Skip to content

Commit 42fc6cc

Browse files
tailhooktailhook
committed
Upgraded implementation to new rotor and rotor-stream
1 parent c2d7aae commit 42fc6cc

11 files changed

+160
-158
lines changed

‎Cargo.toml

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -13,19 +13,18 @@ authors = ["[email protected]"]
1313
[dependencies]
1414
hyper = "0.7"
1515
httparse = "1.1"
16-
netbuf = "0.3.1"
1716
log = "0.3"
1817
time = "0.1"
19-
mio = "0.5"
20-
rotor = "0.4.0"
21-
rotor-stream = "0.3.0"
18+
rotor = {git="git://github.com/tailhook/rotor", rev="cde4393"}
19+
rotor-stream = {git="git://github.com/tailhook/rotor-stream", rev="3b703b2"}
2220
quick-error = "0.2.1"
2321
matches = "0.1"
2422
ip = "1.0.0"
2523

2624
[dev-dependencies]
2725
libc = "0.1"
2826
net2 = "0.2"
27+
argparse = "0.2.1"
2928

3029
[lib]
3130
name = "rotor_http"

‎examples/hello_world_server.rs

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
1-
extern crate hyper;
21
extern crate rotor;
32
extern crate rotor_stream;
43
extern crate rotor_http;
5-
extern crate mio;
64
extern crate time;
75

86

97
use rotor::Scope;
10-
use hyper::status::StatusCode::{self, NotFound};
11-
use hyper::header::ContentLength;
8+
use rotor_http::status::StatusCode::{self, NotFound};
9+
use rotor_http::header::ContentLength;
10+
use rotor_http::uri::RequestUri;
1211
use rotor_stream::{Deadline, Accept, Stream};
1312
use rotor_http::server::{RecvMode, Server, Head, Response, Parser};
14-
use mio::tcp::{TcpListener, TcpStream};
13+
use rotor_http::server::{Context as HttpContext};
14+
use rotor::mio::tcp::TcpListener;
1515
use time::Duration;
1616

1717

@@ -47,35 +47,36 @@ enum HelloWorld {
4747
}
4848

4949
fn send_string(res: &mut Response, data: &[u8]) {
50-
res.status(hyper::status::StatusCode::Ok);
50+
res.status(StatusCode::Ok);
5151
res.add_header(ContentLength(data.len() as u64)).unwrap();
5252
res.done_headers().unwrap();
5353
res.write_body(data);
5454
res.done();
5555
}
5656

57-
impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
58-
fn headers_received(_head: &Head, _scope: &mut Scope<C>)
57+
impl Server for HelloWorld {
58+
type Context = Context;
59+
fn headers_received(_head: &Head, _scope: &mut Scope<Context>)
5960
-> Result<(Self, RecvMode, Deadline), StatusCode>
6061
{
6162
Ok((HelloWorld::Start, RecvMode::Buffered(1024),
6263
Deadline::now() + Duration::seconds(10)))
6364
}
6465
fn request_start(self, head: Head, _res: &mut Response,
65-
scope: &mut Scope<C>)
66+
scope: &mut Scope<Context>)
6667
-> Option<Self>
6768
{
6869
use self::HelloWorld::*;
6970
scope.increment();
7071
match head.uri {
71-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
72+
RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
7273
Some(Hello)
7374
}
74-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
75+
RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
7576
=> {
7677
Some(GetNum)
7778
}
78-
hyper::uri::RequestUri::AbsolutePath(p) => {
79+
RequestUri::AbsolutePath(p) => {
7980
Some(HelloName(p[1..].to_string()))
8081
}
8182
_ => {
@@ -84,7 +85,7 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
8485
}
8586
}
8687
fn request_received(self, _data: &[u8], res: &mut Response,
87-
scope: &mut Scope<C>)
88+
scope: &mut Scope<Context>)
8889
-> Option<Self>
8990
{
9091
use self::HelloWorld::*;
@@ -109,40 +110,39 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
109110
None
110111
}
111112
fn request_chunk(self, _chunk: &[u8], _response: &mut Response,
112-
_scope: &mut Scope<C>)
113+
_scope: &mut Scope<Context>)
113114
-> Option<Self>
114115
{
115116
unreachable!();
116117
}
117118

118119
/// End of request body, only for Progressive requests
119-
fn request_end(self, _response: &mut Response, _scope: &mut Scope<C>)
120+
fn request_end(self, _response: &mut Response, _scope: &mut Scope<Context>)
120121
-> Option<Self>
121122
{
122123
unreachable!();
123124
}
124125

125-
fn timeout(self, _response: &mut Response, _scope: &mut Scope<C>)
126+
fn timeout(self, _response: &mut Response, _scope: &mut Scope<Context>)
126127
-> Option<(Self, Deadline)>
127128
{
128129
unimplemented!();
129130
}
130-
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<C>)
131+
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<Context>)
131132
-> Option<Self>
132133
{
133134
unimplemented!();
134135
}
135136
}
136137

137138
fn main() {
138-
let mut event_loop = mio::EventLoop::new().unwrap();
139+
let mut event_loop = rotor::EventLoop::new().unwrap();
139140
let mut handler = rotor::Handler::new(Context {
140141
counter: 0,
141142
}, &mut event_loop);
142143
let lst = TcpListener::bind(&"127.0.0.1:3000".parse().unwrap()).unwrap();
143144
let ok = handler.add_machine_with(&mut event_loop, |scope| {
144-
Accept::<TcpListener, TcpStream,
145-
Stream<Context, _, Parser<HelloWorld>>>::new(lst, scope)
145+
Accept::<Stream<Parser<HelloWorld, _>>, _>::new(lst, scope)
146146
}).is_ok();
147147
assert!(ok);
148148
event_loop.run(&mut handler).unwrap();

‎examples/threaded.rs

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,19 @@
1-
extern crate hyper;
21
extern crate rotor;
32
extern crate rotor_stream;
43
extern crate rotor_http;
5-
extern crate mio;
64
extern crate time;
75

86

97
use std::env;
108
use std::thread;
119
use rotor::Scope;
12-
use hyper::status::StatusCode::{self, NotFound};
13-
use hyper::header::ContentLength;
10+
use rotor_http::status::StatusCode::{self, NotFound};
11+
use rotor_http::header::ContentLength;
12+
use rotor_http::uri::RequestUri;
1413
use rotor_stream::{Deadline, Accept, Stream};
1514
use rotor_http::server::{RecvMode, Server, Head, Response, Parser};
16-
use mio::tcp::{TcpListener, TcpStream};
15+
use rotor_http::server::{Context as HttpContext};
16+
use rotor::mio::tcp::TcpListener;
1717
use time::Duration;
1818

1919

@@ -49,35 +49,36 @@ enum HelloWorld {
4949
}
5050

5151
fn send_string(res: &mut Response, data: &[u8]) {
52-
res.status(hyper::status::StatusCode::Ok);
52+
res.status(StatusCode::Ok);
5353
res.add_header(ContentLength(data.len() as u64)).unwrap();
5454
res.done_headers().unwrap();
5555
res.write_body(data);
5656
res.done();
5757
}
5858

59-
impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
60-
fn headers_received(_head: &Head, _scope: &mut Scope<C>)
59+
impl Server for HelloWorld {
60+
type Context = Context;
61+
fn headers_received(_head: &Head, _scope: &mut Scope<Context>)
6162
-> Result<(Self, RecvMode, Deadline), StatusCode>
6263
{
6364
Ok((HelloWorld::Start, RecvMode::Buffered(1024),
6465
Deadline::now() + Duration::seconds(10)))
6566
}
6667
fn request_start(self, head: Head, _res: &mut Response,
67-
scope: &mut Scope<C>)
68+
scope: &mut Scope<Context>)
6869
-> Option<Self>
6970
{
7071
use self::HelloWorld::*;
7172
scope.increment();
7273
match head.uri {
73-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
74+
RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
7475
Some(Hello)
7576
}
76-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
77+
RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
7778
=> {
7879
Some(GetNum)
7980
}
80-
hyper::uri::RequestUri::AbsolutePath(p) => {
81+
RequestUri::AbsolutePath(p) => {
8182
Some(HelloName(p[1..].to_string()))
8283
}
8384
_ => {
@@ -86,7 +87,7 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
8687
}
8788
}
8889
fn request_received(self, _data: &[u8], res: &mut Response,
89-
scope: &mut Scope<C>)
90+
scope: &mut Scope<Context>)
9091
-> Option<Self>
9192
{
9293
use self::HelloWorld::*;
@@ -111,25 +112,25 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
111112
None
112113
}
113114
fn request_chunk(self, _chunk: &[u8], _response: &mut Response,
114-
_scope: &mut Scope<C>)
115+
_scope: &mut Scope<Context>)
115116
-> Option<Self>
116117
{
117118
unreachable!();
118119
}
119120

120121
/// End of request body, only for Progressive requests
121-
fn request_end(self, _response: &mut Response, _scope: &mut Scope<C>)
122+
fn request_end(self, _response: &mut Response, _scope: &mut Scope<Context>)
122123
-> Option<Self>
123124
{
124125
unreachable!();
125126
}
126127

127-
fn timeout(self, _response: &mut Response, _scope: &mut Scope<C>)
128+
fn timeout(self, _response: &mut Response, _scope: &mut Scope<Context>)
128129
-> Option<(Self, Deadline)>
129130
{
130131
unimplemented!();
131132
}
132-
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<C>)
133+
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<Context>)
133134
-> Option<Self>
134135
{
135136
unimplemented!();
@@ -144,13 +145,12 @@ fn main() {
144145
for _ in 0..threads {
145146
let listener = lst.try_clone().unwrap();
146147
children.push(thread::spawn(move || {
147-
let mut event_loop = mio::EventLoop::new().unwrap();
148+
let mut event_loop = rotor::EventLoop::new().unwrap();
148149
let mut handler = rotor::Handler::new(Context {
149150
counter: 0,
150151
}, &mut event_loop);
151152
let ok = handler.add_machine_with(&mut event_loop, |scope| {
152-
Accept::<TcpListener, TcpStream,
153-
Stream<Context, _, Parser<HelloWorld>>>::new(
153+
Accept::<Stream<Parser<HelloWorld, _>>, _>::new(
154154
listener, scope)
155155
}).is_ok();
156156
assert!(ok);

‎examples/threaded_reuse_port.rs

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
1-
extern crate hyper;
21
extern crate rotor;
32
extern crate rotor_stream;
43
extern crate rotor_http;
5-
extern crate mio;
64
extern crate net2;
75
extern crate time;
86
extern crate libc;
@@ -13,11 +11,13 @@ use std::thread;
1311
use std::os::unix::io::AsRawFd;
1412

1513
use rotor::Scope;
16-
use hyper::status::StatusCode::{self, NotFound};
17-
use hyper::header::ContentLength;
14+
use rotor_http::status::StatusCode::{self, NotFound};
15+
use rotor_http::header::ContentLength;
16+
use rotor_http::uri::RequestUri;
1817
use rotor_stream::{Deadline, Accept, Stream};
1918
use rotor_http::server::{RecvMode, Server, Head, Response, Parser};
20-
use mio::tcp::{TcpListener, TcpStream};
19+
use rotor_http::server::{Context as HttpContext};
20+
use rotor::mio::tcp::{TcpListener, TcpStream};
2121
use time::Duration;
2222

2323

@@ -53,35 +53,36 @@ enum HelloWorld {
5353
}
5454

5555
fn send_string(res: &mut Response, data: &[u8]) {
56-
res.status(hyper::status::StatusCode::Ok);
56+
res.status(StatusCode::Ok);
5757
res.add_header(ContentLength(data.len() as u64)).unwrap();
5858
res.done_headers().unwrap();
5959
res.write_body(data);
6060
res.done();
6161
}
6262

63-
impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
64-
fn headers_received(_head: &Head, _scope: &mut Scope<C>)
63+
impl Server for HelloWorld {
64+
type Context = Context;
65+
fn headers_received(_head: &Head, _scope: &mut Scope<Context>)
6566
-> Result<(Self, RecvMode, Deadline), StatusCode>
6667
{
6768
Ok((HelloWorld::Start, RecvMode::Buffered(1024),
6869
Deadline::now() + Duration::seconds(10)))
6970
}
7071
fn request_start(self, head: Head, _res: &mut Response,
71-
scope: &mut Scope<C>)
72+
scope: &mut Scope<Context>)
7273
-> Option<Self>
7374
{
7475
use self::HelloWorld::*;
7576
scope.increment();
7677
match head.uri {
77-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
78+
RequestUri::AbsolutePath(ref p) if &p[..] == "/" => {
7879
Some(Hello)
7980
}
80-
hyper::uri::RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
81+
RequestUri::AbsolutePath(ref p) if &p[..] == "/num"
8182
=> {
8283
Some(GetNum)
8384
}
84-
hyper::uri::RequestUri::AbsolutePath(p) => {
85+
RequestUri::AbsolutePath(p) => {
8586
Some(HelloName(p[1..].to_string()))
8687
}
8788
_ => {
@@ -90,7 +91,7 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
9091
}
9192
}
9293
fn request_received(self, _data: &[u8], res: &mut Response,
93-
scope: &mut Scope<C>)
94+
scope: &mut Scope<Context>)
9495
-> Option<Self>
9596
{
9697
use self::HelloWorld::*;
@@ -115,25 +116,25 @@ impl<C:Counter+rotor_http::server::Context> Server<C> for HelloWorld {
115116
None
116117
}
117118
fn request_chunk(self, _chunk: &[u8], _response: &mut Response,
118-
_scope: &mut Scope<C>)
119+
_scope: &mut Scope<Context>)
119120
-> Option<Self>
120121
{
121122
unreachable!();
122123
}
123124

124125
/// End of request body, only for Progressive requests
125-
fn request_end(self, _response: &mut Response, _scope: &mut Scope<C>)
126+
fn request_end(self, _response: &mut Response, _scope: &mut Scope<Context>)
126127
-> Option<Self>
127128
{
128129
unreachable!();
129130
}
130131

131-
fn timeout(self, _response: &mut Response, _scope: &mut Scope<C>)
132+
fn timeout(self, _response: &mut Response, _scope: &mut Scope<Context>)
132133
-> Option<(Self, Deadline)>
133134
{
134135
unimplemented!();
135136
}
136-
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<C>)
137+
fn wakeup(self, _response: &mut Response, _scope: &mut Scope<Context>)
137138
-> Option<Self>
138139
{
139140
unimplemented!();
@@ -155,16 +156,15 @@ fn main() {
155156
}
156157
let addr = &"127.0.0.1:3000".parse().unwrap();
157158
sock.bind(&addr).unwrap();
158-
let listener = mio::tcp::TcpListener::from_listener(
159+
let listener = rotor::mio::tcp::TcpListener::from_listener(
159160
sock.listen(4096).unwrap(), &addr).unwrap();
160161
children.push(thread::spawn(move || {
161-
let mut event_loop = mio::EventLoop::new().unwrap();
162+
let mut event_loop = rotor::EventLoop::new().unwrap();
162163
let mut handler = rotor::Handler::new(Context {
163164
counter: 0,
164165
}, &mut event_loop);
165166
let ok = handler.add_machine_with(&mut event_loop, |scope| {
166-
Accept::<TcpListener, TcpStream,
167-
Stream<Context, _, Parser<HelloWorld>>>::new(
167+
Accept::<Stream<Parser<HelloWorld, _>>, _>::new(
168168
listener, scope)
169169
}).is_ok();
170170
assert!(ok);

0 commit comments

Comments
 (0)