├── .gitignore
├── .travis.yml
├── Cargo.toml
├── LICENSE
├── README.rst
├── examples
    ├── fetch.rs
    ├── monitor.rs
    └── serve.rs
├── src
    ├── accept.rs
    ├── errors.rs
    ├── extensions.rs
    ├── intention.rs
    ├── lib.rs
    ├── persistent.rs
    ├── protocol.rs
    ├── stream.rs
    ├── substr.rs
    ├── trait_impls.rs
    └── transport.rs
└── vagga.yaml


/.gitignore:
--------------------------------------------------------------------------------
1 | /.vagga
2 | /Cargo.lock
3 | /target
4 | /tmp
5 | 
6 | 
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: rust
 2 | rust:
 3 | - stable
 4 | - beta
 5 | - nightly
 6 | sudo: false
 7 | env:
 8 |   secure: "e7tLN2ucVjZXPaA7egf0zSd8ZxMEL8RFIT9Og53XeryPmp4kthFC6f12w+HcockJHfZoXFYqryu7uNw91AXz/y/04zjT6yWR8h0ei1o0AHpduKpf5xLyj94kBZBEBq/9B2gqG1YeCtO34IwvzZqufqNR3LWuRf27Wy2bRVexcHjnxhfQ+vop09jehqHWAyN9uqVMH5Ov38c+X6EeKvk0NYP4cpE8BC/CPWto2653zONizqOIg6oGtfYF30tMjMOeLkOyVUxb5K0QSLLAkyFPYTwIIaSHH4ErmoXtMO7DCygB6yhI5qhylFV3jZSCXJBaKW+gycj8OiSrZ7xvjvoYiZ6tafoqn5+wG48gLljid1LY6SbdXw0KMbR9JPSyZ/Nm8TOm6pdokThQ9A7oZPwIGOM1HHAkiV/1+sXNbOWrF1yBgWLmpucQgQ1bjKblQqFIngmxflONmnT+lrMQfO0iReuvEjo2EyvTSp4hqX/2ur06G4YfqGyau1psHXL+QVhWRussvjMMYN6Bh3sbiJuFIbVe6NaYwWdvA1rfeBe1P/wbWkakwMVqe350blIIJ2TgfsYyXrQ18f2eqHNOXIZkYyrUFVHSgOriW6Z9w1F/kiECI5xeW7AwYbfPIkPUFZchnvCkAdV+/VLzPIVufk07RtIYngy/H84H/Lpqt3P069c="
 9 | script:
10 | - cargo build --verbose
11 | - cargo test --verbose
12 | after_success: |
13 |   [ $TRAVIS_RUST_VERSION = stable ] &&
14 |   [ $TRAVIS_BRANCH = master ] &&
15 |   [ $TRAVIS_PULL_REQUEST = false ] &&
16 |   cargo doc &&
17 |   echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2 | tr '-' '_'`/index.html>" > target/doc/index.html &&
18 |   pip install ghp-import --user &&
19 |   ~/.local/bin/ghp-import -n target/doc &&
20 |   git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
21 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "rotor-stream"
 3 | description = """
 4 |     The stream abstration on top of rotor. This is the easiest way to build a
 5 |     protocol on top of TCP (Unix sockets) with rotor
 6 | """
 7 | license = "MIT"
 8 | readme = "README.rst"
 9 | keywords = ["stream", "rotor", "tcp", "sockets", "mio"]
10 | homepage = "http://github.com/tailhook/rotor-stream"
11 | version = "0.6.2"
12 | authors = ["paul@colomiets.name"]
13 | 
14 | [dependencies]
15 | rotor = "0.6.1"
16 | rotor-tools = { optional = true, version = "0.3.1"}
17 | netbuf = "0.3.1"
18 | memchr = "0.1.7"
19 | quick-error = "0.2.1"
20 | log = "0.3.5"
21 | 
22 | [dev-dependencies]
23 | argparse = "0.2.1"
24 | nix = "0.4.2"
25 | httparse = "1.1.0"
26 | env_logger = "0.3.2"
27 | 
28 | [features]
29 | default = ["replaceable"]
30 | replaceable = ["rotor-tools"]
31 | 
32 | [lib]
33 | name = "rotor_stream"
34 | path = "src/lib.rs"
35 | 
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Paul Colomiets
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
 1 | ============
 2 | Rotor Stream
 3 | ============
 4 | 
 5 | :Status: Alpha
 6 | :Dependencies: rotor_, mio_, netbuf_
 7 | 
 8 | .. _rotor: http://github.com/tailhook/rotor
 9 | .. _mio: https://github.com/carllerche/mio
10 | .. _netbuf: https://github.com/tailhook/netbuf
11 | 
12 | A stream abstraction based on MIO. Features:
13 | 
14 | * State machine-based implementation (as usually in rotor_)
15 | * Uses netbuf_ for buffering, buffer has contiguous data slice (easy parsing)
16 | * Input data abstractions: read-x-bytes, read-until-delimiter
17 | * Perfect for request-reply style protocols
18 | * Independent of whether it's client or server, tcp or unix sockets
19 | * (TODO) should work on top of SSL later
20 | 


--------------------------------------------------------------------------------
/examples/fetch.rs:
--------------------------------------------------------------------------------
  1 | use std::process::exit;
  2 | 
  3 | extern crate nix;
  4 | extern crate rotor;
  5 | extern crate rotor_stream;
  6 | extern crate argparse;
  7 | extern crate httparse;
  8 | 
  9 | use std::cmp::max;
 10 | use std::str::from_utf8;
 11 | use std::net::ToSocketAddrs;
 12 | use std::io::{stdout, stderr, Write};
 13 | use std::time::Duration;
 14 | use std::error::Error;
 15 | 
 16 | use argparse::{ArgumentParser, Store};
 17 | use rotor::mio::tcp::{TcpStream};
 18 | use rotor_stream::{Stream, Transport, Protocol, Intent, Exception};
 19 | use rotor::{Scope};
 20 | 
 21 | 
 22 | struct Context;
 23 | 
 24 | enum Http {
 25 |     SendRequest(String),
 26 |     ReadHeaders,
 27 |     ReadBody,
 28 | }
 29 | 
 30 | 
 31 | impl<'a> Protocol for Http {
 32 |     type Context = Context;
 33 |     type Socket = TcpStream;
 34 |     type Seed = (String, String);
 35 |     fn create((host, path): Self::Seed, _sock: &mut TcpStream,
 36 |         scope: &mut Scope<Context>)
 37 |         -> Intent<Self>
 38 |     {
 39 |         // Wait socket to become writable
 40 |         let req = format!(concat!(
 41 |                 "GET {} HTTP/1.1\r\n",
 42 |                 "Host: {}\r\n",
 43 |                 "\r\n"),
 44 |             path, host);
 45 |         println!("----- Request -----");
 46 |         print!("{}", req);
 47 |         Intent::of(Http::SendRequest(req)).expect_flush()
 48 |             .deadline(scope.now() + Duration::new(10, 0))
 49 |     }
 50 |     fn bytes_flushed(self, transport: &mut Transport<TcpStream>,
 51 |         scope: &mut Scope<Context>)
 52 |         -> Intent<Self>
 53 |     {
 54 |         match self {
 55 |             Http::SendRequest(val) => {
 56 |                 transport.output().extend(val.as_bytes());
 57 |                 Intent::of(Http::ReadHeaders)
 58 |                     .expect_delimiter(b"\r\n\r\n", 4096)
 59 |                     .deadline(scope.now() + Duration::new(10, 0))
 60 |             }
 61 |             _ => unreachable!(),
 62 |         }
 63 |     }
 64 |     fn bytes_read(self, transport: &mut Transport<TcpStream>,
 65 |                   end: usize, scope: &mut Scope<Context>)
 66 |         -> Intent<Self>
 67 |     {
 68 |         match self {
 69 |             Http::SendRequest(_) => unreachable!(),
 70 |             Http::ReadHeaders => {
 71 |                 let mut headers = [httparse::EMPTY_HEADER; 16];
 72 |                 {
 73 |                     let mut req = httparse::Response::new(&mut headers);
 74 |                     let buf = &transport.input()[..end+4];
 75 |                     req.parse(buf).unwrap();
 76 |                 }
 77 |                 let mut clen = 0;
 78 |                 println!("----- Headers -----");
 79 |                 for header in headers.iter() {
 80 |                     println!("{}: {}",
 81 |                         header.name,
 82 |                         from_utf8(header.value).unwrap());
 83 |                     let hlower = header.name.to_lowercase();
 84 |                     if &hlower[..] == "content-length" {
 85 |                         if let Some(val) = from_utf8(header.value).ok()
 86 |                                            .and_then(|x| x.parse().ok()) {
 87 |                             clen = val;
 88 |                             break;
 89 |                         }
 90 |                     }
 91 |                 }
 92 |                 println!("----- Body [{}] -----", clen);
 93 |                 transport.input().consume(end + 4);
 94 |                 Intent::of(Http::ReadBody).expect_bytes(clen)
 95 |                     .deadline(scope.now() +
 96 |                               Duration::new(max(10, clen as u64), 0))
 97 |             }
 98 |             Http::ReadBody => {
 99 |                 let newline = {
100 |                     let data = &transport.input()[..];
101 |                     data.len() > 0 && &data[data.len()-1..] != b"\n"
102 |                 };
103 |                 transport.input().write_to(&mut stdout()).ok();
104 |                 if newline {
105 |                     println!("");
106 |                 }
107 |                 println!("----- Done -----");
108 |                 Intent::done()
109 |             }
110 |         }
111 |     }
112 |     fn timeout(self, _transport: &mut Transport<TcpStream>,
113 |         _scope: &mut Scope<Context>)
114 |         -> Intent<Self>
115 |     {
116 |         writeln!(&mut stderr(), "Timeout reached").ok();
117 |         Intent::done()
118 |     }
119 | 
120 |     /// Message received (from the main loop)
121 |     fn wakeup(self, _transport: &mut Transport<TcpStream>,
122 |         _scope: &mut Scope<Context>)
123 |         -> Intent<Self>
124 |     {
125 |         unreachable!();
126 |     }
127 | 
128 |     fn exception(self, _transport: &mut Transport<Self::Socket>,
129 |         reason: Exception, scope: &mut Scope<Self::Context>)
130 |         -> Intent<Self>
131 |     {
132 |         writeln!(&mut stderr(), "Error when fetching data: {}", reason).ok();
133 |         scope.shutdown_loop();
134 |         Intent::done()
135 |     }
136 |     fn fatal(self, reason: Exception, scope: &mut Scope<Self::Context>)
137 |         -> Option<Box<Error>>
138 |     {
139 |         writeln!(&mut stderr(), "Error when fetching data: {}", reason).ok();
140 |         scope.shutdown_loop();
141 |         None
142 |     }
143 | }
144 | 
145 | fn main() {
146 |     let mut url = "".to_string();
147 |     {
148 |         let mut ap = ArgumentParser::new();
149 |         ap.set_description("
150 |             Fetches some url. Only http, and only fixed size pages are
151 |             supported (i.e. where Content-Length is set)
152 |             ");
153 |         ap.refer(&mut url).add_argument("url", Store, "
154 |             The url to fetch.");
155 |         ap.parse_args_or_exit();
156 |     }
157 |     if !url.starts_with("http://") {
158 |         println!("Url should start with http://");
159 |         exit(1);
160 |     }
161 |     let (host, path) = if let Some(idx) = url[7..].find('/') {
162 |         (&url[7..idx+7], &url[idx+7..])
163 |     } else {
164 |         (&url[7..], "/")
165 |     };
166 |     println!("Host: {} (port: 80), path: {}", host, path);
167 | 
168 |     let event_loop = rotor::Loop::new(&rotor::Config::new()).unwrap();
169 | 
170 |     let sock = TcpStream::connect(
171 |         // Any better way for current stable rust?
172 |         &(host, 80).to_socket_addrs().unwrap().next().unwrap()).unwrap();
173 | 
174 |     let mut loop_inst = event_loop.instantiate(Context);
175 |     loop_inst.add_machine_with(|scope| {
176 |         Stream::<Http>::new(
177 |             sock, (host.to_string(), path.to_string()),
178 |             scope)
179 |     }).unwrap();
180 |     loop_inst.run().unwrap();
181 | }
182 | 


--------------------------------------------------------------------------------
/examples/monitor.rs:
--------------------------------------------------------------------------------
  1 | extern crate nix;
  2 | extern crate rotor;
  3 | extern crate rotor_stream;
  4 | extern crate argparse;
  5 | extern crate httparse;
  6 | extern crate env_logger;
  7 | 
  8 | use std::cmp::max;
  9 | use std::str::from_utf8;
 10 | use std::net::ToSocketAddrs;
 11 | use std::io::{stdout, stderr, Write};
 12 | use std::time::Duration;
 13 | use std::error::Error;
 14 | 
 15 | use rotor::mio::tcp::{TcpStream};
 16 | use rotor_stream::{Persistent, Transport, Protocol, Intent, Exception};
 17 | use rotor::{Scope};
 18 | 
 19 | 
 20 | struct Context;
 21 | 
 22 | #[derive(Debug)]
 23 | enum Http {
 24 |     SendRequest(String),
 25 |     ReadHeaders(String),
 26 |     ReadBody(String),
 27 |     Sleep(String),
 28 | }
 29 | 
 30 | 
 31 | impl<'a> Protocol for Http {
 32 |     type Context = Context;
 33 |     type Socket = TcpStream;
 34 |     type Seed = (String, String);
 35 |     fn create((host, path): Self::Seed, _sock: &mut TcpStream,
 36 |         scope: &mut Scope<Context>)
 37 |         -> Intent<Self>
 38 |     {
 39 |         println!("create");
 40 |         // Wait socket to become writable
 41 |         let req = format!(concat!(
 42 |                 "GET {} HTTP/1.1\r\n",
 43 |                 "Host: {}\r\n",
 44 |                 "User-Agent: curl\r\n", // required for timeapi.org
 45 |                 "\r\n"),
 46 |             path, host);
 47 |         Intent::of(Http::SendRequest(req)).expect_flush()
 48 |             .deadline(scope.now() + Duration::new(10, 0))
 49 |     }
 50 |     fn bytes_flushed(self, transport: &mut Transport<TcpStream>,
 51 |         scope: &mut Scope<Context>)
 52 |         -> Intent<Self>
 53 |     {
 54 |         println!("bytes_flushed {:?}", self);
 55 |         match self {
 56 |             Http::SendRequest(s) => {
 57 |                 transport.output().extend(s.as_bytes());
 58 |                 Intent::of(Http::ReadHeaders(s))
 59 |                     .expect_delimiter(b"\r\n\r\n", 4096)
 60 |                     .deadline(scope.now() + Duration::new(10, 0))
 61 |             }
 62 |             _ => unreachable!(),
 63 |         }
 64 |     }
 65 |     fn bytes_read(self, transport: &mut Transport<TcpStream>,
 66 |                   end: usize, scope: &mut Scope<Context>)
 67 |         -> Intent<Self>
 68 |     {
 69 |         println!("bytes_read {:?}", self);
 70 |         match self {
 71 |             Http::Sleep(x) => Intent::of(Http::Sleep(x)).sleep()
 72 |                               // Imprecise, still good enough
 73 |                               .deadline(scope.now() + Duration::new(5, 0)),
 74 |             Http::SendRequest(_) => unreachable!(),
 75 |             Http::ReadHeaders(s) => {
 76 |                 let mut headers = [httparse::EMPTY_HEADER; 16];
 77 |                 {
 78 |                     let mut req = httparse::Response::new(&mut headers);
 79 |                     let buf = &transport.input()[..end+4];
 80 |                     req.parse(buf).unwrap();
 81 |                 }
 82 |                 let mut clen = 0;
 83 |                 for header in headers.iter() {
 84 |                     let hlower = header.name.to_lowercase();
 85 |                     if &hlower[..] == "content-length" {
 86 |                         if let Some(val) = from_utf8(header.value).ok()
 87 |                                            .and_then(|x| x.parse().ok()) {
 88 |                             clen = val;
 89 |                             break;
 90 |                         }
 91 |                     }
 92 |                 }
 93 |                 transport.input().consume(end + 4);
 94 |                 Intent::of(Http::ReadBody(s)).expect_bytes(clen)
 95 |                     .deadline(scope.now() + Duration::new(
 96 |                         max(10, clen as u64), 0))
 97 |             }
 98 |             Http::ReadBody(s) => {
 99 |                 let newline = {
100 |                     let data = &transport.input()[..];
101 |                     data.len() > 0 && &data[data.len()-1..] != b"\n"
102 |                 };
103 |                 transport.input().write_to(&mut stdout()).ok();
104 |                 if newline {
105 |                     println!("");
106 |                 }
107 |                 println!("at {:?} wait for {:?} ",
108 |                     scope.now(), scope.now() + Duration::new(10, 0));
109 |                 Intent::of(Http::Sleep(s)).sleep()
110 |                     .deadline(scope.now() + Duration::new(10, 0))
111 |             }
112 |         }
113 |     }
114 |     fn timeout(self, _transport: &mut Transport<TcpStream>,
115 |         scope: &mut Scope<Context>)
116 |         -> Intent<Self>
117 |     {
118 |         println!("timeout {:?} at {:?}", self, scope.now());
119 |         match self {
120 |             Http::Sleep(x) => {
121 |                 Intent::of(Http::SendRequest(x)).expect_flush()
122 |                     .deadline(scope.now() + Duration::new(10, 0))
123 |             }
124 |             _ => {
125 |                 writeln!(&mut stderr(), "Timeout reached").ok();
126 |                 Intent::done()
127 |             }
128 |         }
129 |     }
130 | 
131 |     /// Message received (from the main loop)
132 |     fn wakeup(self, _transport: &mut Transport<TcpStream>,
133 |         _scope: &mut Scope<Context>)
134 |         -> Intent<Self>
135 |     {
136 |         unreachable!("wakeup");
137 |     }
138 | 
139 |     fn exception(self, _transport: &mut Transport<Self::Socket>,
140 |         reason: Exception, _scope: &mut Scope<Self::Context>)
141 |         -> Intent<Self>
142 |     {
143 |         writeln!(&mut stderr(), "Error when fetching data: {}", reason).ok();
144 |         Intent::done()
145 |     }
146 |     fn fatal(self, reason: Exception, _scope: &mut Scope<Self::Context>)
147 |         -> Option<Box<Error>>
148 |     {
149 |         writeln!(&mut stderr(), "Error when fetching data: {}", reason).ok();
150 |         None
151 |     }
152 | }
153 | 
154 | fn main() {
155 |     env_logger::init().expect("Can't initialize logging");
156 |     let event_loop = rotor::Loop::new(&rotor::Config::new()).unwrap();
157 | 
158 |     let mut loop_inst = event_loop.instantiate(Context);
159 |     loop_inst.add_machine_with(|scope| {
160 |         Persistent::<Http>::connect(scope,
161 |             ("www.timeapi.org", 80).to_socket_addrs().unwrap()
162 |                 .collect::<Vec<_>>()[0],
163 |             ("www.timeapi.org".to_string(), "/utc/now.json".to_string()))
164 |     }).unwrap();
165 |     loop_inst.run().unwrap();
166 | }
167 | 


--------------------------------------------------------------------------------
/examples/serve.rs:
--------------------------------------------------------------------------------
 1 | extern crate rotor;
 2 | extern crate rotor_stream;
 3 | 
 4 | use std::io::{Write, stderr};
 5 | use std::error::Error;
 6 | use std::time::Duration;
 7 | 
 8 | use rotor::mio::tcp::{TcpListener, TcpStream};
 9 | use rotor::{Scope};
10 | use rotor_stream::{Accept, Stream, Protocol, Intent, Transport, Exception};
11 | 
12 | 
13 | struct Context;
14 | 
15 | enum Http {
16 |     ReadHeaders,
17 |     SendResponse,
18 | }
19 | 
20 | impl Protocol for Http {
21 |     type Context = Context;
22 |     type Socket = TcpStream;
23 |     type Seed = ();
24 |     fn create(_seed: (), _sock: &mut TcpStream, scope: &mut Scope<Context>)
25 |         -> Intent<Self>
26 |     {
27 |         Intent::of(Http::ReadHeaders).expect_delimiter(b"\r\n\r\n", 4096)
28 |             .deadline(scope.now() + Duration::new(10, 0))
29 |     }
30 |     fn bytes_read(self, transport: &mut Transport<TcpStream>,
31 |                   _end: usize, scope: &mut Scope<Context>)
32 |         -> Intent<Self>
33 |     {
34 |         println!("Request from {:?}", transport.socket().local_addr());
35 |         transport.output().write_all(concat!(
36 |             "HTTP/1.0 200 OK\r\n",
37 |             "Server: rotor-stream-example-serve\r\n",
38 |             "Connection: close\r\n",
39 |             "Content-Length: 14\r\n",
40 |             "\r\n",
41 |             "Hello World!\r\n",
42 |         ).as_bytes()).unwrap();
43 |         Intent::of(Http::SendResponse).expect_flush()
44 |             .deadline(scope.now() + Duration::new(10, 0))
45 |     }
46 |     fn bytes_flushed(self, _transport: &mut Transport<TcpStream>,
47 |                      _scope: &mut Scope<Context>)
48 |         -> Intent<Self>
49 |     {
50 |         // TODO(tailhook) or maybe start over?
51 |         Intent::done()
52 |     }
53 |     fn timeout(self, _transport: &mut Transport<TcpStream>,
54 |         _scope: &mut Scope<Context>)
55 |         -> Intent<Self>
56 |     {
57 |         writeln!(&mut stderr(), "Timeout happened").ok();
58 |         Intent::done()
59 |     }
60 | 
61 |     fn wakeup(self, _transport: &mut Transport<TcpStream>,
62 |         _scope: &mut Scope<Context>)
63 |         -> Intent<Self>
64 |     {
65 |         unreachable!();
66 |     }
67 |     fn exception(self, _transport: &mut Transport<Self::Socket>,
68 |         reason: Exception, _scope: &mut Scope<Self::Context>)
69 |         -> Intent<Self>
70 |     {
71 |         writeln!(&mut stderr(), "Error: {}", reason).ok();
72 |         Intent::done()
73 |     }
74 |     fn fatal(self, reason: Exception, _scope: &mut Scope<Self::Context>)
75 |         -> Option<Box<Error>>
76 |     {
77 |         writeln!(&mut stderr(), "Error: {}", reason).ok();
78 |         None
79 |     }
80 | }
81 | 
82 | fn main() {
83 |     let mut event_loop = rotor::Loop::new(&rotor::Config::new()).unwrap();
84 |     let lst = TcpListener::bind(&"127.0.0.1:3000".parse().unwrap()).unwrap();
85 |     let ok = event_loop.add_machine_with(|scope| {
86 |         Accept::<Stream<Http>, _>::new(lst, (), scope)
87 |     }).is_ok();
88 |     assert!(ok);
89 |     event_loop.run(Context).unwrap();
90 | }
91 | 


--------------------------------------------------------------------------------
/src/accept.rs:
--------------------------------------------------------------------------------
  1 | use std::any::Any;
  2 | 
  3 | use rotor::{Machine, Response, EventSet, PollOpt, Evented};
  4 | use rotor::{Scope, GenericScope, Void};
  5 | use rotor::mio::{TryAccept};
  6 | 
  7 | use {StreamSocket, Accept};
  8 | 
  9 | 
 10 | /// Trait which must be implemented for a state machine to accept connection
 11 | ///
 12 | /// This basically provides alternative constructor for the state machine.
 13 | pub trait Accepted: Machine {
 14 |     type Seed: Clone;
 15 |     type Socket: StreamSocket;
 16 |     /// The constructor of the state machine from the accepted connection
 17 |     fn accepted(sock: Self::Socket, seed: <Self as Accepted>::Seed,
 18 |         scope: &mut Scope<Self::Context>)
 19 |         -> Response<Self, Void>;
 20 | }
 21 | 
 22 | 
 23 | impl<M, A> Accept<M, A>
 24 |     where A: TryAccept<Output=M::Socket> + Evented + Any,
 25 |           M: Accepted,
 26 | {
 27 |     pub fn new<S: GenericScope>(sock: A,
 28 |         seed: <M as Accepted>::Seed, scope: &mut S)
 29 |         -> Response<Self, Void>
 30 |     {
 31 |         match scope.register(&sock, EventSet::readable(), PollOpt::edge()) {
 32 |             Ok(()) => {}
 33 |             Err(e) => return Response::error(Box::new(e)),
 34 |         }
 35 |         Response::ok(Accept::Server(sock, seed))
 36 |     }
 37 | }
 38 | 
 39 | impl<M, A> Machine for Accept<M, A>
 40 |     where A: TryAccept<Output=M::Socket> + Evented + Any,
 41 |           M: Accepted,
 42 | {
 43 |     type Context = M::Context;
 44 |     type Seed = (A::Output, <M as Accepted>::Seed);
 45 |     fn create((sock, seed): Self::Seed, scope: &mut Scope<Self::Context>)
 46 |         -> Response<Self, Void>
 47 |     {
 48 |         M::accepted(sock, seed, scope).wrap(Accept::Connection)
 49 |     }
 50 | 
 51 |     fn ready(self, events: EventSet, scope: &mut Scope<Self::Context>)
 52 |         -> Response<Self, Self::Seed>
 53 |     {
 54 |         match self {
 55 |             Accept::Server(a, s) => {
 56 |                 match a.accept() {
 57 |                     Ok(Some(sock)) => {
 58 |                         let seed = (sock, s.clone());
 59 |                         Response::spawn(Accept::Server(a, s), seed)
 60 |                     }
 61 |                     Ok(None) =>  {
 62 |                         Response::ok(Accept::Server(a, s))
 63 |                     }
 64 |                     Err(_) => {
 65 |                         // TODO(tailhook) maybe log the error
 66 |                         Response::ok(Accept::Server(a, s))
 67 |                     }
 68 |                 }
 69 |             }
 70 |             Accept::Connection(m) => {
 71 |                 m.ready(events, scope)
 72 |                     .map(Accept::Connection, |_| unreachable!())
 73 |             }
 74 |         }
 75 |     }
 76 | 
 77 |     fn spawned(self, _scope: &mut Scope<Self::Context>)
 78 |         -> Response<Self, Self::Seed>
 79 |     {
 80 |         match self {
 81 |             Accept::Server(a, s) => {
 82 |                 match a.accept() {
 83 |                     Ok(Some(sock)) => {
 84 |                         let seed = (sock, s.clone());
 85 |                         Response::spawn(Accept::Server(a, s), seed)
 86 |                     }
 87 |                     Ok(None) =>  {
 88 |                         Response::ok(Accept::Server(a, s))
 89 |                     }
 90 |                     Err(_) => {
 91 |                         // TODO(tailhook) maybe log the error
 92 |                         Response::ok(Accept::Server(a, s))
 93 |                     }
 94 |                 }
 95 |             }
 96 |             Accept::Connection(_) => {
 97 |                 unreachable!();
 98 |             }
 99 |         }
100 |     }
101 | 
102 |     fn timeout(self, scope: &mut Scope<Self::Context>)
103 |         -> Response<Self, Self::Seed>
104 |     {
105 |         match self {
106 |             Accept::Server(..) => unreachable!(),
107 |             Accept::Connection(m) => {
108 |                 m.timeout(scope).map(Accept::Connection, |_| unreachable!())
109 |             }
110 |         }
111 |     }
112 | 
113 |     fn wakeup(self, scope: &mut Scope<Self::Context>)
114 |         -> Response<Self, Self::Seed>
115 |     {
116 |         match self {
117 |             me @ Accept::Server(..) => Response::ok(me),
118 |             Accept::Connection(m) => {
119 |                 m.wakeup(scope).map(Accept::Connection, |_| unreachable!())
120 |             }
121 |         }
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/errors.rs:
--------------------------------------------------------------------------------
 1 | use std::fmt;
 2 | use std::error::Error;
 3 | 
 4 | /// Protocol returned None right at the start of the stream processing
 5 | #[derive(Debug)]
 6 | pub struct ProtocolStop;
 7 | 
 8 | impl fmt::Display for ProtocolStop {
 9 |     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
10 |         write!(fmt, "ProtocolStop")
11 |     }
12 | }
13 | 
14 | impl Error for ProtocolStop {
15 |     fn cause(&self) -> Option<&Error> { None }
16 |     fn description(&self) -> &'static str {
17 |         r#"Protocol returned None (which means "stop") at start"#
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/extensions.rs:
--------------------------------------------------------------------------------
 1 | use std::time::Duration;
 2 | 
 3 | use rotor::{Time, Response, GenericScope};
 4 | 
 5 | 
 6 | pub trait ResponseExt {
 7 |     fn deadline_opt(self, deadline: Option<Time>) -> Self;
 8 | }
 9 | 
10 | impl<M, N> ResponseExt for Response<M, N> {
11 |     fn deadline_opt(self, deadline: Option<Time>) -> Self {
12 |         if let Some(time) = deadline {
13 |             self.deadline(time)
14 |         } else {
15 |             self
16 |         }
17 |     }
18 | }
19 | 
20 | pub trait ScopeExt {
21 |     fn reached(&self, deadline: Option<Time>) -> bool;
22 |     fn after(&self, milliseconds: u64) -> Time;
23 | }
24 | 
25 | impl<T: GenericScope> ScopeExt for T {
26 |     fn reached(&self, deadline: Option<Time>) -> bool {
27 |         deadline.map(|x| self.now() >= x).unwrap_or(false)
28 |     }
29 |     fn after(&self, milliseconds: u64) -> Time {
30 |         self.now() + Duration::from_millis(milliseconds)
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/intention.rs:
--------------------------------------------------------------------------------
 1 | use std::error::Error;
 2 | 
 3 | use rotor::Time;
 4 | 
 5 | 
 6 | use {Expectation, Intent, IntentBuilder};
 7 | 
 8 | impl<M> Intent<M> {
 9 |     /// Start building the Intent object of the state machine
10 |     pub fn of(machine: M) -> IntentBuilder<M> {
11 |         IntentBuilder(machine)
12 |     }
13 |     /// Notifies that state machine has done it's work
14 |     pub fn done() -> Self {
15 |         Intent(Err(None), Expectation::Sleep, None)
16 |     }
17 |     /// Notifies that we have protocol error and connection should be closed
18 |     pub fn error(e: Box<Error>) -> Self {
19 |         Intent(Err(Some(e)), Expectation::Sleep, None)
20 |     }
21 |     /// Add/change the deadline
22 |     ///
23 |     /// Note: if you skip this method on next return timeout will be reset.
24 |     /// Which means this state machine may hang indefinitely.
25 |     pub fn deadline(self, deadline: Time) -> Intent<M> {
26 |         Intent(self.0, self.1, Some(deadline))
27 |     }
28 |     /// Add/change the deadline as an optional value
29 |     ///
30 |     /// Note this will reset timeout if deadline is None, not keep unchanged
31 |     pub fn deadline_opt(self, deadline: Option<Time>) -> Intent<M> {
32 |         Intent(self.0, self.1, deadline)
33 |     }
34 | }
35 | 
36 | impl<M> IntentBuilder<M> {
37 |     pub fn expect_bytes(self, min_bytes: usize) -> Intent<M> {
38 |         Intent(Ok(self.0), Expectation::Bytes(min_bytes), None)
39 |     }
40 |     pub fn expect_delimiter(self, delim: &'static [u8], max_bytes: usize)
41 |         -> Intent<M>
42 |     {
43 |         Intent(Ok(self.0),
44 |                Expectation::Delimiter(0, delim, max_bytes), None)
45 |     }
46 |     pub fn expect_delimiter_after(self, offset: usize,
47 |         delim: &'static [u8], max_bytes: usize)
48 |         -> Intent<M>
49 |     {
50 |         Intent(Ok(self.0),
51 |                Expectation::Delimiter(offset, delim, max_bytes), None)
52 |     }
53 |     pub fn expect_flush(self) -> Intent<M> {
54 |         Intent(Ok(self.0), Expectation::Flush(0), None)
55 |     }
56 |     /// Add a generic expectation
57 |     ///
58 |     /// The method is useful if you're returning an expectation from somewhere
59 |     /// otherwise use specific `expect_*` methods
60 |     pub fn expect(self, e: Expectation) -> Intent<M> {
61 |         Intent(Ok(self.0), e, None)
62 |     }
63 |     pub fn sleep(self) -> Intent<M> {
64 |         Intent(Ok(self.0), Expectation::Sleep, None)
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | //! Stream abstraction for rotor
  2 | //!
  3 | //! The crate provides:
  4 | //!
  5 | //! * Buffering for network sockets
  6 | //! * Simple abstractions like read N bytes, read until '\n'
  7 | //! * Persistent (auto-reconnecting) client connections
  8 | //! * Abstraction for accepting connection on server-side
  9 | //!
 10 | //! Assumptions for streams:
 11 | //!
 12 | //! 1. You read data by length-prefixed or fixed-string-delimited chunks rather
 13 | //!    than byte-by-byte
 14 | //! 2. Each chunk fits memory
 15 | //! 3. Your data stream is not entirely full-duplex: while you can read and
 16 | //!    write simultaneously, when you apply pushback (i.e. waiting for bytes to
 17 | //!    be flushed), you can't do reads [*]
 18 | //!
 19 | //! [*] This matches HTTP perfectly, and most bidirectional interactive
 20 | //!     workflows (including based on websockets). But for some cases may be
 21 | //!     hard to implement. One such case is when you need to generate some
 22 | //!     output stream (you can't buffer it), and have to parse input stream at
 23 | //!     the same time.
 24 | 
 25 | extern crate netbuf;
 26 | extern crate memchr;
 27 | extern crate rotor;
 28 | #[macro_use] extern crate log;
 29 | #[macro_use] extern crate quick_error;
 30 | #[cfg(feature="replaceable")] extern crate rotor_tools;
 31 | 
 32 | 
 33 | mod substr;
 34 | mod transport;
 35 | mod protocol;
 36 | mod stream;
 37 | mod accept;
 38 | mod persistent;
 39 | mod trait_impls;
 40 | mod intention;
 41 | mod extensions;
 42 | mod errors;
 43 | 
 44 | pub use protocol::{Protocol, Expectation, Exception};
 45 | pub use accept::{Accepted};
 46 | pub use persistent::{Persistent};
 47 | pub use errors::ProtocolStop;
 48 | #[cfg(feature="replaceable")] pub use rotor_tools::sync;
 49 | 
 50 | use std::any::Any;
 51 | use std::io;
 52 | use std::io::{Read, Write};
 53 | use std::error::Error;
 54 | 
 55 | use rotor::{Evented, Time};
 56 | use rotor::mio::{TryAccept};
 57 | 
 58 | pub use netbuf::{Buf, MAX_BUF_SIZE};
 59 | 
 60 | // Any is needed to use Stream as a Seed for Machine
 61 | pub trait StreamSocket: Read + Write + Evented + SocketError + Sized + Any {}
 62 | 
 63 | /// Transport is thing that provides buffered I/O for stream sockets
 64 | ///
 65 | /// This is usually passed in all the `Protocol` handler methods. But in
 66 | /// case you manipulate the transport by some external methods (like the
 67 | /// one stored in `Arc<Mutex<Stream>>` you may wish to use `Stream::transport`
 68 | /// or `Persistent::transport` methods to manipulate tranpsport. Just remember
 69 | /// to **wake up** the state machine after manipulating buffers of transport.
 70 | pub struct Transport<'a, S: StreamSocket> {
 71 |     sock: &'a mut S,
 72 |     inbuf: &'a mut Buf,
 73 |     outbuf: &'a mut Buf,
 74 | }
 75 | 
 76 | /// Socket acceptor State Machine
 77 | ///
 78 | /// TODO(tailhook) Currently this panics when there is no slab space when
 79 | /// accepting a connection. This may be fixed by sleeping and retrying
 80 | pub enum Accept<M, A: TryAccept+Sized>
 81 |     where A::Output: StreamSocket,
 82 |           M: Accepted<Socket=A::Output>,
 83 | {
 84 |     Server(A, <M as Accepted>::Seed),
 85 |     Connection(M),
 86 | }
 87 | 
 88 | /// A main stream state machine abstaction
 89 | ///
 90 | /// You may use the `Stream` directly. But it's recommented to either use
 91 | /// `Persistent` for client connections or `Accept` for server-side
 92 | /// connection processing.
 93 | #[derive(Debug)]
 94 | pub struct Stream<P: Protocol> {
 95 |     socket: P::Socket,
 96 |     fsm: P,
 97 |     expectation: Expectation,
 98 |     connected: bool,
 99 |     deadline: Option<Time>,
100 |     inbuf: Buf,
101 |     outbuf: Buf,
102 | }
103 | 
104 | struct StreamImpl<S: StreamSocket> {
105 |     socket: S,
106 |     connected: bool,
107 |     inbuf: Buf,
108 |     outbuf: Buf,
109 | }
110 | 
111 | pub trait ActiveStream: StreamSocket {
112 |     type Address;
113 |     fn connect(addr: &Self::Address) -> io::Result<Self>;
114 | }
115 | 
116 | pub trait SocketError {
117 |     fn take_socket_error(&self) -> io::Result<()>;
118 | }
119 | 
120 | /// A structure that encapsulates a state machine and an expectation
121 | ///
122 | /// It's usually built with a builder that starts with `Intent::of(machine)`.
123 | ///
124 | /// Then you add an expectation:
125 | ///
126 | /// ```ignore
127 | /// Intent::of(machine).expect_delimiter("\n", 1024)
128 | /// ```
129 | ///
130 | /// And then you may add a timeout (in form of "deadline" or "absolute time"):
131 | ///
132 | /// ```ignore
133 | /// Intent::of(machine).expect_bytes(100)
134 | ///     .deadline(scope.now() + Duration::new(10, 0))
135 | /// ```
136 | ///
137 | #[derive(Debug)]
138 | pub struct Intent<M>(Result<M, Option<Box<Error>>>, Expectation, Option<Time>);
139 | 
140 | /// A helper class returned from `Intent::of()`
141 | ///
142 | /// See the documentation of `Intent` for guide
143 | #[derive(Debug)]
144 | pub struct IntentBuilder<M>(M);
145 | 


--------------------------------------------------------------------------------
/src/persistent.rs:
--------------------------------------------------------------------------------
  1 | use std::fmt::Debug;
  2 | use std::error::Error;
  3 | 
  4 | use rotor::{Machine, EventSet, PollOpt, Scope, Response, Time};
  5 | use rotor::void::{unreachable, Void};
  6 | use rotor::{GenericScope};
  7 | 
  8 | use {ActiveStream, Protocol, Stream, ProtocolStop, Transport};
  9 | use extensions::{ResponseExt, ScopeExt};
 10 | 
 11 | 
 12 | /// Reconnect timeout in milliseconds.
 13 | ///
 14 | /// TODO(tailhook) should be overridable at runtime
 15 | pub const RECONNECT_TIMEOUT: u64 = 200;
 16 | 
 17 | /// Time for establishing a connection
 18 | ///
 19 | /// TODO(tailhook) should be overridable at runtime
 20 | pub const CONNECT_TIMEOUT: u64 = 1_000;
 21 | 
 22 | 
 23 | /// Persistent client connection
 24 | ///
 25 | /// TODO(tailhook) this should include name resolution
 26 | pub struct Persistent<P>(<P::Socket as ActiveStream>::Address,
 27 |                          P::Seed, Fsm<P>)
 28 |     where P: Protocol, P::Socket: ActiveStream;
 29 | 
 30 | #[derive(Debug)]
 31 | pub enum Fsm<P: Protocol> {
 32 |     Idle,
 33 |     Connecting(P::Socket, Time),
 34 |     Established(Stream<P>),
 35 |     Sleeping(Time),
 36 | }
 37 | 
 38 | fn response<P>(addr: <P::Socket as ActiveStream>::Address,
 39 |     seed: P::Seed, fsm: Fsm<P>)
 40 |     -> Response<Persistent<P>, Void>
 41 |     where P: Protocol, P::Socket: ActiveStream
 42 | {
 43 |     use self::Fsm::*;
 44 |     let timeo = match *&fsm {
 45 |         Idle => None,
 46 |         Connecting(_, tm) => Some(tm),
 47 |         // Can't find out a timeout for established connection
 48 |         // some other way should be used for this case
 49 |         Established(..) => unreachable!(),
 50 |         Sleeping(tm) => Some(tm),
 51 |     };
 52 |     Response::ok(Persistent(addr, seed, fsm))
 53 |         .deadline_opt(timeo)
 54 | }
 55 | 
 56 | impl<P> Persistent<P>
 57 |     where P: Protocol,
 58 |           P::Socket: ActiveStream,
 59 |           <P::Socket as ActiveStream>::Address: Debug
 60 | {
 61 |     pub fn new<S: GenericScope>(_scope: &mut S,
 62 |             address: <P::Socket as ActiveStream>::Address, seed: P::Seed)
 63 |         -> Response<Persistent<P>, Void>
 64 |     {
 65 |         Response::ok(Persistent(address, seed, Fsm::Idle))
 66 |     }
 67 | 
 68 |     pub fn connect<S: GenericScope>(scope: &mut S,
 69 |             address: <P::Socket as ActiveStream>::Address, seed: P::Seed)
 70 |         -> Response<Persistent<P>, Void>
 71 |     {
 72 |         let fsm = match P::Socket::connect(&address) {
 73 |             Ok(sock) => {
 74 |                 scope.register(&sock, EventSet::writable(), PollOpt::level())
 75 |                     .expect("Can't register socket");
 76 |                 Fsm::Connecting(sock, scope.after(CONNECT_TIMEOUT))
 77 |             }
 78 |             Err(e) => {
 79 |                 info!("Failed to connect to {:?}: {}", address, e);
 80 |                 Fsm::Sleeping(scope.after(RECONNECT_TIMEOUT))
 81 |             }
 82 |         };
 83 |         response(address, seed, fsm)
 84 |     }
 85 | }
 86 | 
 87 | impl<P> Persistent<P>
 88 |     where P: Protocol, P::Socket: ActiveStream
 89 | {
 90 |     /// Get a `Transport` object of the underlying stream
 91 |     ///
 92 |     /// This method is only useful if you want to manipulate buffers
 93 |     /// externally (like pushing to the buffer from another thread). Just be
 94 |     /// sure to **wake up** state machine after manipulating buffers.
 95 |     ///
 96 |     /// Returns `None` if stream is not currently connected
 97 |     pub fn transport(&mut self) -> Option<Transport<P::Socket>> {
 98 |         match self.2 {
 99 |             Fsm::Established(ref mut s) => Some(s.transport()),
100 |             _ => None,
101 |         }
102 |     }
103 |     /// Get a `Protocol` object for the stream
104 |     ///
105 |     /// This method is only useful if you want to adjust protocol dysyr
106 |     /// externally (like update some values after pushing data to buffer).
107 |     /// Just be sure to **wake up** state machine if needed by the protocol.
108 |     pub fn protocol(&mut self) -> Option<&mut P> {
109 |         match self.2 {
110 |             Fsm::Established(ref mut s) => Some(s.protocol()),
111 |             _ => None,
112 |         }
113 |     }
114 | }
115 | 
116 | impl<P> Fsm<P>
117 |     where P: Protocol,
118 |           P::Seed: Clone,
119 |           P::Socket: ActiveStream,
120 |           <P::Socket as ActiveStream>::Address: Debug
121 | {
122 |     fn action<S: GenericScope>(resp: Response<Stream<P>, Void>,
123 |         addr: <P::Socket as ActiveStream>::Address,
124 |         seed: P::Seed, scope: &mut S)
125 |         -> Response<Persistent<P>, Void>
126 |     {
127 |         if resp.is_stopped() {
128 |             if let Some(err) = resp.cause() {
129 |                 warn!("Connection is failed: {}", err);
130 |             } else {
131 |                 warn!("Connection is stopped by protocol");
132 |             }
133 |             response(addr, seed,
134 |                 Fsm::Sleeping(scope.after(RECONNECT_TIMEOUT)))
135 |         } else {
136 |             resp
137 |                 .wrap(Fsm::Established)
138 |                 .wrap(|x| Persistent(addr, seed, x))
139 |         }
140 |     }
141 | }
142 | 
143 | impl<P: Protocol> Machine for Persistent<P>
144 |     where P: Protocol,
145 |           P::Seed: Clone,
146 |           P::Socket: ActiveStream,
147 |           <P::Socket as ActiveStream>::Address: Debug
148 | {
149 |     type Context = P::Context;
150 |     type Seed = Void;
151 |     fn create(seed: Self::Seed, _scope: &mut Scope<P::Context>)
152 |         -> Response<Self, Void>
153 |     {
154 |         unreachable(seed)
155 |     }
156 |     fn ready(self, events: EventSet, scope: &mut Scope<P::Context>)
157 |         -> Response<Self, Self::Seed>
158 |     {
159 |         use self::Fsm::*;
160 |         let Persistent(addr, seed, state) = self;
161 |         let state = match state {
162 |             Idle => Idle,  // spurious event
163 |             Connecting(sock, dline) => {
164 |                 if events.is_writable() {
165 |                     let resp =  Stream::connected(sock, seed.clone(), scope);
166 |                     if resp.is_stopped() {
167 |                         error!("Error creating stream FSM: {}",
168 |                             resp.cause().unwrap_or(&ProtocolStop));
169 |                         Fsm::Sleeping(scope.after(RECONNECT_TIMEOUT))
170 |                     } else {
171 |                         return Fsm::action(resp, addr, seed, scope);
172 |                     }
173 |                 } else if events.is_hup() {
174 |                     error!("Connection closed immediately");
175 |                     Fsm::Sleeping(scope.after(RECONNECT_TIMEOUT))
176 |                 } else {
177 |                     Connecting(sock, dline) // spurious event
178 |                 }
179 |             }
180 |             Established(x) => {
181 |                 return Fsm::action(x.ready(events, scope), addr, seed, scope);
182 |             }
183 |             Sleeping(dline) => Sleeping(dline), // spurious event
184 |         };
185 |         response(addr, seed, state)
186 |     }
187 |     fn spawned(self, _scope: &mut Scope<P::Context>)
188 |         -> Response<Self, Self::Seed>
189 |     {
190 |         unreachable!();
191 |     }
192 |     fn timeout(self, scope: &mut Scope<P::Context>)
193 |         -> Response<Self, Self::Seed>
194 |     {
195 |         use self::Fsm::*;
196 |         let Persistent(addr, seed, state) = self;
197 |         let state = match state {
198 |             Idle => Idle,  // spurious timeout
199 |             Connecting(sock, dline) => {
200 |                 if scope.now() >= dline {
201 |                     warn!("Timeout while establishing connection");
202 |                     Fsm::Sleeping(scope.after(RECONNECT_TIMEOUT))
203 |                 } else {  // spurious timeout
204 |                     Connecting(sock, dline)
205 |                 }
206 |             }
207 |             Established(x) => {
208 |                 return Fsm::action(x.timeout(scope), addr, seed, scope);
209 |             }
210 |             Sleeping(dline) => {
211 |                 if scope.now() >= dline {
212 |                     return Self::connect(scope, addr, seed);
213 |                 } else {
214 |                     Sleeping(dline)  // spurious timeout
215 |                 }
216 |             }
217 |         };
218 |         response(addr, seed, state)
219 |     }
220 |     fn wakeup(self, scope: &mut Scope<P::Context>)
221 |         -> Response<Self, Self::Seed>
222 |     {
223 |         use self::Fsm::*;
224 |         let Persistent(addr, seed, state) = self;
225 |         let state = match state {
226 |             Established(x) => {
227 |                 return Fsm::action(x.wakeup(scope), addr, seed, scope);
228 |             }
229 |             x => x, // spurious wakeup
230 |         };
231 |         response(addr, seed, state)
232 |     }
233 | }
234 | 
235 | #[cfg(feature="replaceable")]
236 | mod replaceable {
237 | 
238 |     use std::fmt::Debug;
239 | 
240 |     use {ActiveStream, Protocol, Persistent};
241 |     use rotor_tools::sync::Replaceable;
242 | 
243 |     use super::Fsm;
244 | 
245 |     impl<P: Protocol> Replaceable for Persistent<P>
246 |         where P: Protocol,
247 |               P::Seed: Clone,
248 |               <P::Socket as ActiveStream>::Address: Clone + Debug,
249 |               P::Socket: ActiveStream
250 |     {
251 |         fn empty(&self) -> Self {
252 |             // We assume that cloning is cheap enough. Probably just Copy
253 |             Persistent(self.0.clone(), self.1.clone(), Fsm::Idle)
254 |         }
255 |     }
256 | }
257 | 


--------------------------------------------------------------------------------
/src/protocol.rs:
--------------------------------------------------------------------------------
  1 | use std::io;
  2 | use std::error::Error;
  3 | use rotor::Scope;
  4 | 
  5 | use {Transport, Intent, StreamSocket};
  6 | 
  7 | quick_error!{
  8 |     /// An exception value that is received in `Protocol::exception` method
  9 |     ///
 10 |     /// This thing is usually used for nice error detection. But sometimes it
 11 |     /// is also useful for valid protocol processing. For example it allows
 12 |     /// to detect end-of-stream-delimited prootols (of those which make of
 13 |     /// use of TCP half close)
 14 |     #[derive(Debug)]
 15 |     pub enum Exception {
 16 |         /// End of stream reached (when reading)
 17 |         ///
 18 |         /// This may be not a broken expectation, we just notify of end of
 19 |         /// stream always (if the state machine is still alive)
 20 |         ///
 21 |         /// Note: the equivalent of end of stream for write system call is
 22 |         /// translated to `WriteError(WriteZero)`
 23 |         EndOfStream {
 24 |             description("end of stream reached")
 25 |         }
 26 |         /// Limit for the number of bytes reached
 27 |         ///
 28 |         /// This is called when there is alredy maximum bytes in the buffer
 29 |         /// (third argument of `Delimiter`) but no delimiter found.
 30 |         LimitReached {
 31 |             description("reached the limit of bytes buffered")
 32 |         }
 33 |         ReadError(err: io::Error) {
 34 |             description("error when reading from stream")
 35 |             display("read error: {}", err)
 36 |         }
 37 |         WriteError(err: io::Error) {
 38 |             description("error when writing to stream")
 39 |             display("write error: {}", err)
 40 |         }
 41 |         ConnectError(err: io::Error) {
 42 |             description("error when connecting to an address")
 43 |             display("connection error: {}", err)
 44 |         }
 45 |     }
 46 | }
 47 | 
 48 | 
 49 | /// This is an enumeration used to declare what next protocol is expecting
 50 | ///
 51 | /// The value is used in `Intent::expect()`.
 52 | ///
 53 | /// Most users should use `IntentBuilder`'s (a type which is returned from
 54 | /// `Intent::of(..)`) methods. But for some kinds of control flow being
 55 | /// able to specify expectation as a separate enum is very useful.
 56 | // #[derive(Clone, Clone)]
 57 | // This could be Copy, but I think it could be implemented efficient enough
 58 | // without Copy and Clone. Probably we will enable them for the user code later
 59 | #[derive(Debug)]
 60 | pub enum Expectation {
 61 |     /// Read number of bytes
 62 |     ///
 63 |     /// The buffer that is passed to bytes_read might contain more bytes, but
 64 |     /// `num` parameter of the `bytes_read()` method will contain a number of
 65 |     /// bytes passed into `Bytes` constructor.
 66 |     ///
 67 |     /// Note that bytes passed here is neither limit on bytes actually read
 68 |     /// from the network (we resize buffer as convenient for memory allocator
 69 |     /// and read as much as possible), nor is the preallocated buffer size
 70 |     /// (we don't preallocate the buffer to be less vulnerable to DoS attacks).
 71 |     ///
 72 |     /// Note that real number of bytes that `netbuf::Buf` might contain is less
 73 |     /// than 4Gb. So this value can't be as big as `usize::MAX`
 74 |     Bytes(usize),
 75 |     /// Read until delimiter
 76 |     ///
 77 |     /// Parameters: `offset`, `delimiter`, `max_bytes`
 78 |     ///
 79 |     /// Only static strings are supported for delimiter now.
 80 |     ///
 81 |     /// `bytes_read` action gets passed `num` bytes before the delimeter, or
 82 |     /// in other words, the position of the delimiter in the buffer.
 83 |     /// The delimiter is guaranteed to be in the buffer too. The `max_bytes`
 84 |     /// do include the offset itself.
 85 |     ///
 86 |     Delimiter(usize, &'static [u8], usize),
 87 |     /// Wait until no more than N bytes is in output buffer
 88 |     ///
 89 |     /// This is going to be used for several cases:
 90 |     ///
 91 |     /// 1. `Flush(0)` before closing the connection
 92 |     /// 2. `Flush(0)` to before receiving new request (if needed)
 93 |     /// 3. `Flush(N)` to wait when you can continue producing some data, this
 94 |     ///    allows TCP pushback. To be able not to put everything in output
 95 |     ///    buffer at once. Still probably more efficient than `Flush(0)`
 96 |     Flush(usize),
 97 |     /// Wait until deadline
 98 |     ///
 99 |     /// This useful for two cases:
100 |     ///
101 |     /// 1. Just wait before doing anything if required by business logic
102 |     /// 2. Wait until `wakeup` happens or atimeout whatever comes first
103 |     Sleep,
104 | }
105 | 
106 | pub trait Protocol: Sized {
107 |     type Context;
108 |     type Socket: StreamSocket;
109 |     type Seed;
110 |     /// Starting the protocol (e.g. accepted a socket)
111 |     // TODO(tailhook) transport be here instead of sock?
112 |     fn create(seed: Self::Seed, sock: &mut Self::Socket,
113 |         scope: &mut Scope<Self::Context>)
114 |         -> Intent<Self>;
115 | 
116 |     /// The action WaitBytes or WaitDelimiter is complete
117 |     ///
118 |     /// Note you don't have to consume input buffer. The data is in the
119 |     /// transport, but you are free to ignore it. This may be useful for
120 |     /// example to yield `Bytes(4)` to read the header size and then yield
121 |     /// bigger value to read the whole header at once. But be careful, if
122 |     /// you don't consume bytes you will repeatedly receive them again.
123 |     fn bytes_read(self, transport: &mut Transport<Self::Socket>,
124 |                   end: usize, scope: &mut Scope<Self::Context>)
125 |         -> Intent<Self>;
126 | 
127 |     /// The action Flush is complete
128 |     fn bytes_flushed(self, transport: &mut Transport<Self::Socket>,
129 |                      scope: &mut Scope<Self::Context>)
130 |         -> Intent<Self>;
131 | 
132 |     /// Timeout happened, which means either deadline reached in
133 |     /// Bytes, Delimiter, Flush. Or Sleep has passed.
134 |     fn timeout(self, transport: &mut Transport<Self::Socket>,
135 |         scope: &mut Scope<Self::Context>)
136 |         -> Intent<Self>;
137 | 
138 |     /// The method is called when too much bytes are read but no delimiter
139 |     /// is found within the number of bytes specified. Or end of stream reached
140 |     ///
141 |     /// The usual case is to just close the connection (because it's probably
142 |     /// DoS attack is going on or the protocol mismatch), but sometimes you
143 |     /// want to send error code, like 413 Entity Too Large for HTTP.
144 |     ///
145 |     /// Note it's your responsibility to wait for the buffer to be flushed.
146 |     /// If you write to the buffer and then return Intent::done() immediately,
147 |     /// your data will be silently discarded.
148 |     ///
149 |     /// The `WriteError` and `ConnectError` are never passed here but passed
150 |     /// into `fatal` handler instead.
151 |     fn exception(self, _transport: &mut Transport<Self::Socket>,
152 |         reason: Exception, _scope: &mut Scope<Self::Context>)
153 |         -> Intent<Self>;
154 | 
155 |     /// This method is called on fatal errors of the connection
156 |     ///
157 |     /// Connection can't proceed after this method is called
158 |     ///
159 |     /// Note: we use shared `Exception` type for both exception and fatal
160 |     /// exceptions. This method receives ``WriteError`` and ``ConnectError``
161 |     /// options only.
162 |     fn fatal(self, reason: Exception, scope: &mut Scope<Self::Context>)
163 |         -> Option<Box<Error>>;
164 | 
165 |     /// Message received (from the main loop)
166 |     fn wakeup(self, transport: &mut Transport<Self::Socket>,
167 |         scope: &mut Scope<Self::Context>)
168 |         -> Intent<Self>;
169 | }
170 | 


--------------------------------------------------------------------------------
/src/stream.rs:
--------------------------------------------------------------------------------
  1 | use std::io;
  2 | use std::error::Error;
  3 | use std::io::ErrorKind::{WouldBlock, BrokenPipe, WriteZero, ConnectionReset};
  4 | 
  5 | use rotor::{Response, Scope, Machine, EventSet, PollOpt, Time};
  6 | use rotor::void::{Void, unreachable};
  7 | 
  8 | use substr::find_substr;
  9 | use extensions::{ScopeExt, ResponseExt};
 10 | use {Expectation, Protocol, StreamSocket, Stream, StreamImpl};
 11 | use {Buf, Transport, Accepted, Exception, Intent};
 12 | use {ProtocolStop, SocketError};
 13 | 
 14 | 
 15 | #[derive(Debug)]
 16 | enum IoOp {
 17 |     Done,
 18 |     NoOp,
 19 |     Eos,
 20 |     Error(io::Error),
 21 | }
 22 | 
 23 | fn to_result<P: Protocol>(intent: Intent<P>)
 24 |     -> Result<(P, Expectation, Option<Time>), Option<Box<Error>>>
 25 | {
 26 |     match intent.0 {
 27 |         Ok(x) => Ok((x, intent.1, intent.2)),
 28 |         Err(e) => Err(e),
 29 |     }
 30 | }
 31 | 
 32 | impl<S: StreamSocket> StreamImpl<S> {
 33 |     fn transport(&mut self) -> Transport<S> {
 34 |         Transport {
 35 |             sock: &mut self.socket,
 36 |             inbuf: &mut self.inbuf,
 37 |             outbuf: &mut self.outbuf,
 38 |         }
 39 |     }
 40 |     fn action<M>(self, intent: Intent<M>,
 41 |         scope: &mut Scope<M::Context>)
 42 |         -> Response<Stream<M>, Void>
 43 |         where M: Protocol<Socket=S>
 44 |     {
 45 |         match self._action(intent, scope) {
 46 |             Ok(stream) => {
 47 |                 let dline = stream.deadline;
 48 |                 Response::ok(stream).deadline_opt(dline)
 49 |             }
 50 |             Err(Some(e)) => Response::error(e),
 51 |             Err(None) => Response::done(),
 52 |         }
 53 |     }
 54 |     fn _action<P>(mut self, intent: Intent<P>,
 55 |         scope: &mut Scope<P::Context>)
 56 |         -> Result<Stream<P>, Option<Box<Error>>>
 57 |         where P: Protocol<Socket=S>
 58 |     {
 59 |         use Expectation::*;
 60 |         let mut intent = try!(to_result(intent));
 61 |         let mut can_write = match self.write() {
 62 |             IoOp::Done => true,
 63 |             IoOp::NoOp => false,
 64 |             IoOp::Eos => {
 65 |                 self.outbuf.remove_range(..);
 66 |                 return Err(intent.0.fatal(
 67 |                     Exception::WriteError(io::Error::new(
 68 |                         WriteZero, "failed to write whole buffer")),
 69 |                     scope));
 70 |             }
 71 |             IoOp::Error(e) => {
 72 |                 return Err(intent.0.fatal(
 73 |                     Exception::WriteError(e),
 74 |                     scope));
 75 |             }
 76 |         };
 77 |         'outer: loop {
 78 |             if can_write {
 79 |                 can_write = match self.write() {
 80 |                     IoOp::Done => true,
 81 |                     IoOp::NoOp => false,
 82 |                     IoOp::Eos => {
 83 |                         self.outbuf.remove_range(..);
 84 |                         return Err(intent.0.fatal(
 85 |                             Exception::WriteError(io::Error::new(
 86 |                                 WriteZero, "failed to write whole buffer")),
 87 |                             scope));
 88 |                     }
 89 |                     IoOp::Error(e) => {
 90 |                         self.outbuf.remove_range(..);
 91 |                         return Err(intent.0.fatal(
 92 |                             Exception::WriteError(e),
 93 |                             scope));
 94 |                     }
 95 |                 };
 96 |             }
 97 |             match intent.1 {
 98 |                 Bytes(num) => {
 99 |                     loop {
100 |                         if self.inbuf.len() >= num {
101 |                             intent = try!(to_result(intent.0.bytes_read(
102 |                                 &mut self.transport(),
103 |                                 num, scope)));
104 |                             continue 'outer;
105 |                         }
106 |                         match self.read() {
107 |                             IoOp::Done => {}
108 |                             IoOp::NoOp => {
109 |                                 return Ok(Stream::compose(self, intent));
110 |                             }
111 |                             IoOp::Eos => {
112 |                                 intent = try!(to_result(intent.0.exception(
113 |                                     &mut self.transport(),
114 |                                     Exception::EndOfStream,
115 |                                     scope)));
116 |                                 continue 'outer;
117 |                             }
118 |                             IoOp::Error(e) => {
119 |                                 intent = try!(to_result(intent.0.exception(
120 |                                     &mut self.transport(),
121 |                                     Exception::ReadError(e),
122 |                                     scope)));
123 |                                 continue 'outer;
124 |                             }
125 |                         }
126 |                     }
127 |                 }
128 |                 Delimiter(min, delim, max) => {
129 |                     loop {
130 |                         if self.inbuf.len() > min {
131 |                             let opt = find_substr(&self.inbuf[min..], delim);
132 |                             if let Some(num) = opt {
133 |                                 intent = try!(to_result(intent.0.bytes_read(
134 |                                     &mut self.transport(),
135 |                                     num, scope)));
136 |                                 continue 'outer;
137 |                             }
138 |                         }
139 |                         if self.inbuf.len() > max {
140 |                             intent = try!(to_result(intent.0.exception(
141 |                                 &mut self.transport(),
142 |                                 Exception::LimitReached,
143 |                                 scope)));
144 |                             continue 'outer;
145 |                         }
146 |                         match self.read() {
147 |                             IoOp::Done => {}
148 |                             IoOp::NoOp => {
149 |                                 return Ok(Stream::compose(self, intent));
150 |                             }
151 |                             IoOp::Eos => {
152 |                                 intent = try!(to_result(intent.0.exception(
153 |                                     &mut self.transport(),
154 |                                     Exception::EndOfStream,
155 |                                     scope)));
156 |                                 continue 'outer;
157 |                             }
158 |                             IoOp::Error(e) => {
159 |                                 intent = try!(to_result(intent.0.exception(
160 |                                     &mut self.transport(),
161 |                                     Exception::ReadError(e),
162 |                                     scope)));
163 |                                 continue 'outer;
164 |                             }
165 |                         }
166 |                     }
167 |                 }
168 |                 Flush(num) => {
169 |                     if self.outbuf.len() <= num {
170 |                         intent = try!(to_result(intent.0.bytes_flushed(
171 |                             &mut self.transport(), scope)));
172 |                     } else {
173 |                         return Ok(Stream::compose(self, intent));
174 |                     }
175 |                 }
176 |                 Sleep => {
177 |                     return Ok(Stream::compose(self, intent));
178 |                 }
179 |             }
180 |         }
181 |     }
182 |     // Returns Ok(true) to if we have read something, does not loop for reading
183 |     // because this might use whole memory, and we may parse and consume the
184 |     // input instead of buffering it whole.
185 |     fn read(&mut self) -> IoOp {
186 |         match self.inbuf.read_from(&mut self.socket) {
187 |             Ok(0) => IoOp::Eos,
188 |             Ok(_) => IoOp::Done,
189 |             Err(ref e) if e.kind() == BrokenPipe
190 |                        || e.kind() == ConnectionReset
191 |             => return IoOp::Eos,
192 |             Err(ref e) if e.kind() == WouldBlock => IoOp::NoOp,
193 |             Err(e) => IoOp::Error(e),
194 |         }
195 |     }
196 |     fn write(&mut self) -> IoOp {
197 |         loop {
198 |             if self.outbuf.len() == 0 {
199 |                 return IoOp::Done;
200 |             }
201 |             match self.outbuf.write_to(&mut self.socket) {
202 |                 Ok(0) => return IoOp::Eos,
203 |                 Ok(_) => continue,
204 |                 Err(ref e) if e.kind() == BrokenPipe
205 |                            || e.kind() == ConnectionReset
206 |                 => return IoOp::Eos,
207 |                 Err(ref e) if e.kind() == WouldBlock => return IoOp::NoOp,
208 |                 Err(e) => return IoOp::Error(e),
209 |             }
210 |         }
211 |     }
212 | }
213 | 
214 | impl<P: Protocol> Accepted for Stream<P>
215 |     where <P as Protocol>::Seed: Clone
216 | {
217 |     type Seed = <P as Protocol>::Seed;
218 |     type Socket = P::Socket;
219 |     fn accepted(sock: P::Socket, seed: <P as Protocol>::Seed,
220 |         scope: &mut Scope<Self::Context>)
221 |         -> Response<Self, Void>
222 |     {
223 |         Self::new(sock, seed, scope)
224 |     }
225 | }
226 | 
227 | impl<P: Protocol> Stream<P> {
228 |     /// Get a `Transport` object for the stream
229 |     ///
230 |     /// This method is only useful if you want to manipulate buffers
231 |     /// externally (like pushing to the buffer from another thread). Just be
232 |     /// sure to **wake up** state machine after manipulating buffers.
233 |     pub fn transport(&mut self) -> Transport<P::Socket> {
234 |         Transport {
235 |             sock: &mut self.socket,
236 |             inbuf: &mut self.inbuf,
237 |             outbuf: &mut self.outbuf,
238 |         }
239 |     }
240 |     /// Get a `Protocol` object for the stream
241 |     ///
242 |     /// This method is only useful if you want to adjust protocol dysyr
243 |     /// externally (like update some values after pushing data to buffer).
244 |     /// Just be sure to **wake up** state machine if needed by the protocol.
245 |     pub fn protocol(&mut self) -> &mut P {
246 |         &mut self.fsm
247 |     }
248 |     fn decompose(self) -> (P, Expectation, Option<Time>, StreamImpl<P::Socket>)
249 |     {
250 |         (self.fsm, self.expectation, self.deadline, StreamImpl {
251 |             socket: self.socket,
252 |             connected: self.connected,
253 |             inbuf: self.inbuf,
254 |             outbuf: self.outbuf,
255 |         })
256 |     }
257 |     fn compose(implem: StreamImpl<P::Socket>,
258 |         (fsm, exp, dline): (P, Expectation, Option<Time>))
259 |         -> Stream<P>
260 |     {
261 |         Stream {
262 |             fsm: fsm,
263 |             socket: implem.socket,
264 |             expectation: exp,
265 |             connected: implem.connected,
266 |             deadline: dline,
267 |             inbuf: implem.inbuf,
268 |             outbuf: implem.outbuf,
269 |         }
270 |     }
271 |     pub fn new(mut sock: P::Socket, seed: P::Seed,
272 |         scope: &mut Scope<P::Context>)
273 |         -> Response<Self, Void>
274 |     {
275 |         // Always register everything in edge-triggered mode.
276 |         // This allows to never reregister socket.
277 |         //
278 |         // The no-reregister strategy is not a goal (although, it's expected
279 |         // to lower number of syscalls for many request-reply-like protocols)
280 |         // but it allows to have single source of truth for
281 |         // readable()/writable() mask (no duplication in kernel space)
282 |         if let Err(e) = scope.register(&sock,
283 |             EventSet::all(), PollOpt::edge())
284 |         {
285 |             // TODO(tailhook) wrap it to more clear error
286 |             return Response::error(Box::new(e));
287 |         }
288 |         let Intent(m, exp, dline) = P::create(seed, &mut sock, scope);
289 |         match m {
290 |             Err(None) => Response::error(Box::new(ProtocolStop)),
291 |             Err(Some(e)) => Response::error(e),
292 |             Ok(m) => {
293 |                 Response::ok(Stream {
294 |                     socket: sock,
295 |                     expectation: exp,
296 |                     connected: false,
297 |                     deadline: dline,
298 |                     fsm: m,
299 |                     inbuf: Buf::new(),
300 |                     outbuf: Buf::new(),
301 |                 }).deadline_opt(dline)
302 |             }
303 |         }
304 |     }
305 |     pub fn connected(mut sock: P::Socket, seed: P::Seed,
306 |         scope: &mut Scope<P::Context>)
307 |         -> Response<Self, Void>
308 |     {
309 |         // Always register everything in edge-triggered mode.
310 |         // This allows to never reregister socket.
311 |         //
312 |         // The no-reregister strategy is not a goal (although, it's expected
313 |         // to lower number of syscalls for many request-reply-like protocols)
314 |         // but it allows to have single source of truth for
315 |         // readable()/writable() mask (no duplication in kernel space)
316 |         //
317 |         // We reregister here, because we assume that higher level abstraction
318 |         // has the socket already registered (perhaps `Persistent` machine)
319 |         if let Err(e) = scope.reregister(&sock,
320 |             EventSet::all(), PollOpt::edge())
321 |         {
322 |             // TODO(tailhook) wrap it to more clear error
323 |             return Response::error(Box::new(e));
324 |         }
325 |         let Intent(m, exp, dline) = P::create(seed, &mut sock, scope);
326 |         match m {
327 |             Err(None) => Response::error(Box::new(ProtocolStop)),
328 |             Err(Some(e)) => Response::error(e),
329 |             Ok(m) => {
330 |                 Response::ok(Stream {
331 |                     socket: sock,
332 |                     expectation: exp,
333 |                     connected: true,
334 |                     deadline: dline,
335 |                     fsm: m,
336 |                     inbuf: Buf::new(),
337 |                     outbuf: Buf::new(),
338 |                 }).deadline_opt(dline)
339 |             }
340 |         }
341 |     }
342 | }
343 | 
344 | impl<P: Protocol> Machine for Stream<P>
345 | {
346 |     type Context = P::Context;
347 |     type Seed = Void;
348 |     fn create(void: Void, _scope: &mut Scope<Self::Context>)
349 |         -> Response<Self, Void>
350 |     {
351 |         unreachable(void);
352 |     }
353 |     fn ready(self, events: EventSet, scope: &mut Scope<Self::Context>)
354 |         -> Response<Self, Self::Seed>
355 |     {
356 |         // TODO(tailhook) use `events` to optimize reading
357 |         let (fsm, exp, dline, mut imp) = self.decompose();
358 |         if events.is_hup() || events.is_error() {
359 |             match imp.socket.take_socket_error() {
360 |                 Ok(()) => {
361 |                     match fsm.fatal(Exception::EndOfStream, scope) {
362 |                         Some(e) => return Response::error(e),
363 |                         None => return Response::done(),
364 |                     }
365 |                 }
366 |                 Err(e) => {
367 |                     let exception = if imp.connected {
368 |                         Exception::ReadError(e)
369 |                     } else {
370 |                         Exception::ConnectError(e)
371 |                     };
372 |                     match fsm.fatal(exception, scope) {
373 |                         Some(e) => return Response::error(e),
374 |                         None => return Response::done(),
375 |                     }
376 |                 }
377 |             }
378 |         } else if !imp.connected {
379 |             imp.connected = true;
380 |         }
381 |         imp.action(Intent(Ok(fsm), exp, dline), scope)
382 |     }
383 |     fn spawned(self, _scope: &mut Scope<Self::Context>)
384 |         -> Response<Self, Self::Seed>
385 |     {
386 |         unreachable!();
387 |     }
388 |     fn timeout(self, scope: &mut Scope<Self::Context>)
389 |         -> Response<Self, Self::Seed>
390 |     {
391 |         if scope.reached(self.deadline) {
392 |             let (fsm, _exp, _dline, mut imp) = self.decompose();
393 |             let res = fsm.timeout(&mut imp.transport(), scope);
394 |             imp.action(res, scope)
395 |         } else {
396 |             // TODO(tailhook) in rotor 0.6 should be no spurious timeouts
397 |             // anymore, but let's keep it until we remove Scope::timeout_ms()
398 |             Response::ok(self)
399 |         }
400 |     }
401 |     fn wakeup(self, scope: &mut Scope<Self::Context>)
402 |         -> Response<Self, Self::Seed>
403 |     {
404 |         let (fsm, _exp, _dline, mut imp) = self.decompose();
405 |         let res = fsm.wakeup(&mut imp.transport(), scope);
406 |         imp.action(res, scope)
407 |     }
408 | }
409 | 


--------------------------------------------------------------------------------
/src/substr.rs:
--------------------------------------------------------------------------------
 1 | use memchr::memchr;
 2 | 
 3 | 
 4 | /// Finds subslice in a slice of a buffer.
 5 | /// It is the fastest known implementation of the thing.
 6 | ///
 7 | // If you know any faster way to do this send a pull request
 8 | pub fn find_substr<B:AsRef<[u8]>, N:AsRef<[u8]>>(haystack: B, needle: N)
 9 |     -> Option<usize>
10 | {
11 |     let haystack = haystack.as_ref();
12 |     let needle = needle.as_ref();
13 |     debug_assert!(needle.len() > 0);
14 |     if needle.len() > haystack.len() {
15 |         return None;
16 |     }
17 |     let mut offset = 0;
18 |     let end = haystack.len() - needle.len()+1;
19 |     loop {
20 |         match memchr(needle[0], &haystack[offset..end]) {
21 |             Some(x) if &haystack[offset+x..offset+x+needle.len()] == needle
22 |             => {
23 |                 return Some(offset+x);
24 |             }
25 |             Some(x) => {
26 |                 offset += x + 1;
27 |                 continue;
28 |             }
29 |             None => {
30 |                 return None;
31 |             }
32 |         }
33 |     }
34 | }
35 | 
36 | #[cfg(test)]
37 | mod test {
38 |     use super::find_substr;
39 | 
40 |     #[test]
41 |     fn middle() {
42 |         assert_eq!(find_substr("hello\r\n\r\nworld", "\r\n\r\n"), Some(5));
43 |     }
44 | 
45 |     #[test]
46 |     fn end() {
47 |         assert_eq!(find_substr("hello world\r\n\r\n", "\r\n\r\n"), Some(11));
48 |     }
49 |     #[test]
50 |     fn partial() {
51 |         assert_eq!(find_substr("hello\r\nworld\r\n\r\n", "\r\n\r\n"), Some(12));
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/trait_impls.rs:
--------------------------------------------------------------------------------
 1 | use std::io;
 2 | use std::any::Any;
 3 | use std::net::SocketAddr;
 4 | #[cfg(unix)]
 5 | use std::path::PathBuf;
 6 | 
 7 | use rotor::mio::Evented;
 8 | use rotor::mio::tcp;
 9 | #[cfg(unix)]
10 | use rotor::mio::unix;
11 | 
12 | use {StreamSocket, ActiveStream, SocketError};
13 | 
14 | impl<T> StreamSocket for T
15 |     where T: io::Read, T: io::Write, T: Evented, T:SocketError, T:Any
16 | {}
17 | 
18 | impl ActiveStream for tcp::TcpStream {
19 |     type Address = SocketAddr;
20 |     fn connect(addr: &SocketAddr) -> io::Result<Self> {
21 |         tcp::TcpStream::connect(addr)
22 |     }
23 | }
24 | 
25 | #[cfg(unix)]
26 | impl ActiveStream for unix::UnixStream {
27 |     type Address = PathBuf;
28 |     fn connect(addr: &PathBuf) -> io::Result<Self> {
29 |         unix::UnixStream::connect(addr)
30 |     }
31 | }
32 | 
33 | impl SocketError for tcp::TcpStream {
34 |     fn take_socket_error(&self) -> io::Result<()> {
35 |         tcp::TcpStream::take_socket_error(self)
36 |     }
37 | }
38 | 
39 | #[cfg(unix)]
40 | impl SocketError for unix::UnixStream {
41 |     fn take_socket_error(&self) -> io::Result<()> {
42 |         Ok(())
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/transport.rs:
--------------------------------------------------------------------------------
 1 | use {Buf, Transport, StreamSocket};
 2 | 
 3 | 
 4 | impl<'a, S: StreamSocket> Transport<'a, S> {
 5 |     /// Get the reference to the underlying stream
 6 |     ///
 7 |     /// It's here so you can inspect socket state or tune it. For example you
 8 |     /// might want to set TCP_CORK option or find out peer or local address.
 9 |     ///
10 |     /// Reading from and writing to a socket directly may lead to unexpected
11 |     /// behavior. Use `input()` and `output()` buffers instead.
12 |     pub fn socket<'x>(&'x mut self) -> &'x mut S {
13 |         self.sock
14 |     }
15 |     /// Get a reference to the input buffer
16 |     ///
17 |     /// It's expected that you only read and `consume()` bytes from buffer
18 |     /// but never write.
19 |     pub fn input<'x>(&'x mut self) -> &'x mut Buf {
20 |         self.inbuf
21 |     }
22 |     /// Get a reference to the output buffer
23 |     ///
24 |     /// It's expected that you only inspect and write to the output buffer
25 |     /// but never `consume()`
26 |     pub fn output<'x>(&'x mut self) -> &'x mut Buf {
27 |         self.outbuf
28 |     }
29 |     /// Get a references to both buffers (input, output)
30 |     ///
31 |     /// It's useful when you want to pass both things somewhere along the
32 |     /// chain of calls. See `input()` and `output()` methods for more comments
33 |     /// on buffer usage
34 |     pub fn buffers<'x>(&'x mut self) -> (&'x mut Buf, &'x mut Buf) {
35 |         (self.inbuf, self.outbuf)
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/vagga.yaml:
--------------------------------------------------------------------------------
 1 | commands:
 2 | 
 3 |   make: !Command
 4 |     description: Build rotor library
 5 |     container: ubuntu
 6 |     run: [cargo, build]
 7 | 
 8 |   test: !Command
 9 |     description: Run unit tests
10 |     container: ubuntu
11 |     run: [cargo, test]
12 | 
13 |   cargo: !Command
14 |     description: Run any cargo command
15 |     container: ubuntu
16 |     run: [cargo]
17 | 
18 | containers:
19 | 
20 |   ubuntu:
21 |     setup:
22 |     - !Ubuntu trusty
23 |     - !UbuntuUniverse ~
24 |     - !Install [make, checkinstall, wget, ca-certificates,
25 |                 libssl-dev, build-essential]
26 | 
27 |     - !TarInstall
28 |       url: "http://static.rust-lang.org/dist/rust-1.6.0-x86_64-unknown-linux-gnu.tar.gz"
29 |       script: "./install.sh --prefix=/usr \
30 |                --components=rustc,rust-std-x86_64-unknown-linux-gnu,cargo"
31 | 
32 |     environ:
33 |       HOME: /work/target
34 | 


--------------------------------------------------------------------------------