From 897bf84163fbd9de49233404b44fd7e50f9656e6 Mon Sep 17 00:00:00 2001 From: Oliver Gould Date: Fri, 8 Sep 2017 17:20:41 +0000 Subject: [PATCH] Use rustfmt to enforce consistent formatting This change adds a .rustfmt.toml that includes ALL supported settings, 12 of which we have overridden to attempt to cater to our own proclivities. rustfmt is checked in the rust-nightly CI job. --- .rustfmt.toml | 84 +++++ .travis.yml | 6 +- CONTRIBUTING.md | 95 ++++++ examples/akamai.rs | 35 +- examples/client.rs | 77 +++-- examples/server-tr.rs | 31 +- examples/server.rs | 31 +- src/client.rs | 173 +++++----- src/codec/error.rs | 9 +- src/codec/framed_read.rs | 35 +- src/codec/framed_write.rs | 12 +- src/codec/mod.rs | 39 +-- src/error.rs | 12 +- src/frame/data.rs | 17 +- src/frame/go_away.rs | 10 +- src/frame/head.rs | 2 +- src/frame/headers.rs | 67 ++-- src/frame/mod.rs | 10 +- src/frame/ping.rs | 12 +- src/frame/priority.rs | 11 +- src/frame/reason.rs | 5 +- src/frame/reset.rs | 14 +- src/frame/settings.rs | 6 +- src/frame/window_update.rs | 10 +- src/hpack/decoder.rs | 549 +++++++++++++++++------------- src/hpack/encoder.rs | 204 +++++------ src/hpack/header.rs | 156 +++++---- src/hpack/huffman/mod.rs | 38 ++- src/hpack/mod.rs | 4 +- src/hpack/table.rs | 76 ++--- src/hpack/test/fixture.rs | 55 ++- src/hpack/test/fuzz.rs | 56 +-- src/lib.rs | 5 +- src/proto/connection.rs | 75 ++-- src/proto/error.rs | 2 +- src/proto/mod.rs | 4 +- src/proto/peer.rs | 7 +- src/proto/ping_pong.rs | 6 +- src/proto/settings.rs | 26 +- src/proto/streams/buffer.rs | 28 +- src/proto/streams/counts.rs | 13 +- src/proto/streams/flow_control.rs | 14 +- src/proto/streams/mod.rs | 8 +- src/proto/streams/prioritize.rs | 135 +++++--- src/proto/streams/recv.rs | 264 +++++++------- src/proto/streams/send.rs | 134 ++++---- src/proto/streams/state.rs | 64 ++-- src/proto/streams/store.rs | 86 +++-- src/proto/streams/stream.rs | 38 +-- src/proto/streams/streams.rs | 254 +++++++------- src/server.rs | 148 ++++---- tests/client_request.rs | 18 +- tests/codec_read.rs | 19 +- tests/codec_write.rs | 1 + tests/flow_control.rs | 310 ++++++++--------- tests/ping_pong.rs | 9 +- tests/prioritization.rs | 30 +- tests/server.rs | 6 +- tests/stream_states.rs | 50 ++- tests/trailers.rs | 12 +- 60 files changed, 2087 insertions(+), 1620 deletions(-) create mode 100644 .rustfmt.toml create mode 100644 CONTRIBUTING.md diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 0000000..8dda043 --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,84 @@ +# https://github.com/rust-lang-nursery/rustfmt/blob/master/Configurations.md +verbose = false +disable_all_formatting = false +skip_children = false +max_width = 100 +error_on_line_overflow = false +error_on_line_overflow_comments = false +tab_spaces = 4 +fn_call_width = 60 +struct_lit_width = 18 +struct_variant_width = 35 +force_explicit_abi = true +newline_style = "Unix" +fn_brace_style = "SameLineWhere" +item_brace_style = "SameLineWhere" +control_style = "Rfc" +control_brace_style = "AlwaysSameLine" +impl_empty_single_line = true +trailing_comma = "Vertical" +trailing_semicolon = true +fn_empty_single_line = true +fn_single_line = false +fn_return_indent = "WithArgs" +fn_args_paren_newline = false +fn_args_density = "Tall" +fn_args_layout = "Block" +array_layout = "Block" +array_width = 60 +array_horizontal_layout_threshold = 0 +type_punctuation_density = "Wide" +where_style = "Rfc" +where_density = "CompressedIfEmpty" +where_layout = "Vertical" +where_pred_indent = "Visual" +generics_indent = "Block" +struct_lit_style = "Block" +struct_lit_multiline_style = "ForceMulti" +fn_call_style = "Visual" +report_todo = "Never" +report_fixme = "Never" +chain_indent = "Block" +chain_one_line_max = 60 +chain_split_single_child = false +imports_indent = "Block" +imports_layout = "HorizontalVertical" +reorder_extern_crates = true +reorder_extern_crates_in_group = true +reorder_imports = true +reorder_imports_in_group = true +reorder_imported_names = true +single_line_if_else_max_width = 50 +format_strings = true +force_format_strings = false +take_source_hints = false +hard_tabs = false +wrap_comments = false +comment_width = 80 +normalize_comments = false +wrap_match_arms = true +match_block_trailing_comma = false +indent_match_arms = true +match_pattern_separator_break_point = "Back" +closure_block_indent_threshold = 0 +space_before_type_annotation = false +space_after_type_annotation_colon = true +space_before_struct_lit_field_colon = false +space_after_struct_lit_field_colon = true +space_before_bound = false +space_after_bound_colon = true +spaces_around_ranges = false +spaces_within_angle_brackets = false +spaces_within_square_brackets = false +spaces_within_parens = false +use_try_shorthand = true +write_mode = "Overwrite" +condense_wildcard_suffixes = false +combine_control_expr = true +struct_field_align_threshold = 0 +remove_blank_lines_at_start_or_end_of_block = true +attributes_on_same_line_as_field = true +attributes_on_same_line_as_variant = true +multiline_closure_forces_block = false +multiline_match_arm_forces_block = false +merge_derives = true diff --git a/.travis.yml b/.travis.yml index 54e0bfb..38cf179 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,8 +16,12 @@ matrix: - rust: stable - rust: beta - rust: nightly - before_script: + install: - pip install --user travis-cargo codecov && export PATH=$HOME/.local/bin:$PATH + - if ! cargo fmt --help >/dev/null 2>&1 ; then cargo install rustfmt-nightly ; fi + after_script: + # Check formatting + - cargo fmt -- --write-mode=diff after_success: - travis-cargo doc-upload diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..7df04d7 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,95 @@ +# Contributing to _h2_ # + +:balloon: Thanks for your help improving the project! + +## Getting Help ## + +If you have a question about the h2 library or have encountered problems using it, you may +[file an issue][issue] or ask ask a question on the [Tokio Gitter][gitter]. + +## Submitting a Pull Request ## + +Do you have an improvement? + +1. Submit an [issue][issue] describing your proposed change. +2. We will try to respond to your issue promptly. +3. Fork this repo, develop and test your code changes. See the project's [README](README.md) for further information about working in this repository. +4. Submit a pull request against this repo's `master` branch. +6. Your branch may be merged once all configured checks pass, including: + - Code review has been completed. + - The branch has passed tests in CI. + +## Code Style ## + +[`rustfmt-nightly`][rustfmt] is used to enforce a consistent style (as configured by +[`.rustfmt.toml`](./.rustfmt.toml)). Style is checked by CI, so be sure to apply rustfmt +before committing your work. For example: + +``` +$ rustup run nightly cargo install --force rustfmt-nightly + Updating registry `https://github.com/rust-lang/crates.io-index` + Installing rustfmt-nightly v0.2.5 +... +$ rustup run nightly cargo fmt +``` + +## Committing ## + +We prefer squash or rebase commits so that all changes from a branch are +committed to master as a single commit. All pull requests are squashed when +merged, but rebasing prior to merge gives you better control over the commit +message. + +### Commit messages ### + +Finalized commit messages should be in the following format: + +``` +Subject + +Problem + +Solution + +Validation +``` + +#### Subject #### + +- one line, <= 50 characters +- describe what is done; not the result +- use the active voice +- capitalize first word and proper nouns +- do not end in a period — this is a title/subject +- reference the github issue by number + +##### Examples ##### + +``` +bad: server disconnects should cause dst client disconnects. +good: Propagate disconnects from source to destination +``` + +``` +bad: support tls servers +good: Introduce support for server-side TLS (#347) +``` + +#### Problem #### + +Explain the context and why you're making that change. What is the problem +you're trying to solve? In some cases there is not a problem and this can be +thought of as being the motivation for your change. + +#### Solution #### + +Describe the modifications you've made. + +#### Validation #### + +Describe the testing you've done to validate your change. Performance-related +changes should include before- and after- benchmark results. + +[issue]: https://github.com/carllerche/h2/issues/new +[gitter]: https://gitter.im/tokio-rs/tokio +[rustfmt]: https://github.com/rust-lang-nursery/rustfmt diff --git a/examples/akamai.rs b/examples/akamai.rs index c061b70..0a16268 100644 --- a/examples/akamai.rs +++ b/examples/akamai.rs @@ -1,20 +1,20 @@ +extern crate env_logger; +extern crate futures; extern crate h2; extern crate http; -extern crate futures; +extern crate io_dump; extern crate rustls; extern crate tokio_core; extern crate tokio_rustls; extern crate webpki_roots; -extern crate io_dump; -extern crate env_logger; use h2::client::Client; -use http::{Request, Method}; use futures::*; +use http::{Method, Request}; -use tokio_core::reactor; use tokio_core::net::TcpStream; +use tokio_core::reactor; use rustls::Session; use tokio_rustls::ClientConfigExt; @@ -27,26 +27,30 @@ pub fn main() { let _ = env_logger::init(); let tls_client_config = std::sync::Arc::new({ - let mut c = rustls::ClientConfig::new(); - c.root_store.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); - c.alpn_protocols.push(ALPN_H2.to_owned()); - c - }); + let mut c = rustls::ClientConfig::new(); + c.root_store.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); + c.alpn_protocols.push(ALPN_H2.to_owned()); + c + }); // Sync DNS resolution. - let addr = "http2.akamai.com:443".to_socket_addrs() - .unwrap().next().unwrap(); + let addr = "http2.akamai.com:443" + .to_socket_addrs() + .unwrap() + .next() + .unwrap(); println!("ADDR: {:?}", addr); - let mut core = reactor::Core::new().unwrap();; + let mut core = reactor::Core::new().unwrap(); let handle = core.handle(); let tcp = TcpStream::connect(&addr, &handle); let tcp = tcp.then(|res| { let tcp = res.unwrap(); - tls_client_config.connect_async("http2.akamai.com", tcp) + tls_client_config + .connect_async("http2.akamai.com", tcp) .then(|res| { let tls = res.unwrap(); let negotiated_protcol = { @@ -67,7 +71,8 @@ pub fn main() { let request = Request::builder() .method(Method::GET) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let stream = h2.request(request, true).unwrap(); diff --git a/examples/client.rs b/examples/client.rs index dfa177b..6e66391 100644 --- a/examples/client.rs +++ b/examples/client.rs @@ -1,19 +1,19 @@ +extern crate bytes; +extern crate env_logger; +extern crate futures; extern crate h2; extern crate http; -extern crate bytes; -extern crate futures; -extern crate tokio_core; extern crate io_dump; -extern crate env_logger; +extern crate tokio_core; -use h2::client::{Client, Body}; +use h2::client::{Body, Client}; -use http::*; -use futures::*; use bytes::*; +use futures::*; +use http::*; -use tokio_core::reactor; use tokio_core::net::TcpStream; +use tokio_core::reactor; struct Process { body: Body, @@ -49,52 +49,51 @@ impl Future for Process { pub fn main() { let _ = env_logger::init(); - let mut core = reactor::Core::new().unwrap();; + let mut core = reactor::Core::new().unwrap(); let handle = core.handle(); - let tcp = TcpStream::connect( - &"127.0.0.1:5928".parse().unwrap(), - &handle); + let tcp = TcpStream::connect(&"127.0.0.1:5928".parse().unwrap(), &handle); let tcp = tcp.then(|res| { let tcp = io_dump::Dump::to_stdout(res.unwrap()); Client::handshake(tcp) - }) - .then(|res| { - let mut client = res.unwrap(); + }).then(|res| { + let mut client = res.unwrap(); - println!("sending request"); + println!("sending request"); - let request = Request::builder() - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let request = Request::builder() + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - let mut trailers = HeaderMap::new(); - trailers.insert("zomg", "hello".parse().unwrap()); + let mut trailers = HeaderMap::new(); + trailers.insert("zomg", "hello".parse().unwrap()); - let mut stream = client.request(request, false).unwrap(); + let mut stream = client.request(request, false).unwrap(); - // send trailers - stream.send_trailers(trailers).unwrap(); + // send trailers + stream.send_trailers(trailers).unwrap(); - // Spawn a task to run the client... - handle.spawn(client.map_err(|e| println!("GOT ERR={:?}", e))); + // Spawn a task to run the client... + handle.spawn(client.map_err(|e| println!("GOT ERR={:?}", e))); - stream.and_then(|response| { - println!("GOT RESPONSE: {:?}", response); + stream + .and_then(|response| { + println!("GOT RESPONSE: {:?}", response); - // Get the body - let (_, body) = response.into_parts(); + // Get the body + let (_, body) = response.into_parts(); - Process { - body, - trailers: false, - } - }).map_err(|e| { - println!("GOT ERR={:?}", e); - }) - }) - ; + Process { + body, + trailers: false, + } + }) + .map_err(|e| { + println!("GOT ERR={:?}", e); + }) + }); core.run(tcp).unwrap(); } diff --git a/examples/server-tr.rs b/examples/server-tr.rs index 61a1903..4c002b2 100644 --- a/examples/server-tr.rs +++ b/examples/server-tr.rs @@ -1,28 +1,27 @@ + +extern crate bytes; +extern crate env_logger; +extern crate futures; extern crate h2; extern crate http; -extern crate bytes; -extern crate futures; extern crate tokio_core; -extern crate env_logger; use h2::server::Server; -use http::*; use bytes::*; use futures::*; +use http::*; -use tokio_core::reactor; use tokio_core::net::TcpListener; +use tokio_core::reactor; pub fn main() { let _ = env_logger::init(); - let mut core = reactor::Core::new().unwrap();; + let mut core = reactor::Core::new().unwrap(); let handle = core.handle(); - let listener = TcpListener::bind( - &"127.0.0.1:5928".parse().unwrap(), - &handle).unwrap(); + let listener = TcpListener::bind(&"127.0.0.1:5928".parse().unwrap(), &handle).unwrap(); println!("listening on {:?}", listener.local_addr()); @@ -37,9 +36,7 @@ pub fn main() { conn.for_each(|(request, mut stream)| { println!("GOT request: {:?}", request); - let response = Response::builder() - .status(StatusCode::OK) - .body(()).unwrap(); + let response = Response::builder().status(StatusCode::OK).body(()).unwrap(); if let Err(e) = stream.send_response(response, false) { println!(" error responding; err={:?}", e); @@ -60,9 +57,10 @@ pub fn main() { Ok(()) }).and_then(|_| { - println!("~~~~~~~~~~~~~~~~~~~~~~~~~~~ H2 connection CLOSE !!!!!! ~~~~~~~~~~~"); - Ok(()) - }) + println!("~~~~~~~~~~~~~~~~~~~~~~~~~~~ H2 connection CLOSE !!!!!! \ + ~~~~~~~~~~~"); + Ok(()) + }) }) .then(|res| { if let Err(e) = res { @@ -70,8 +68,7 @@ pub fn main() { } Ok(()) - }) - ; + }); handle.spawn(connection); Ok(()) diff --git a/examples/server.rs b/examples/server.rs index f12e663..6f4acbd 100644 --- a/examples/server.rs +++ b/examples/server.rs @@ -1,28 +1,27 @@ + +extern crate bytes; +extern crate env_logger; +extern crate futures; extern crate h2; extern crate http; -extern crate bytes; -extern crate futures; extern crate tokio_core; -extern crate env_logger; use h2::server::Server; -use http::*; use bytes::*; use futures::*; +use http::*; -use tokio_core::reactor; use tokio_core::net::TcpListener; +use tokio_core::reactor; pub fn main() { let _ = env_logger::init(); - let mut core = reactor::Core::new().unwrap();; + let mut core = reactor::Core::new().unwrap(); let handle = core.handle(); - let listener = TcpListener::bind( - &"127.0.0.1:5928".parse().unwrap(), - &handle).unwrap(); + let listener = TcpListener::bind(&"127.0.0.1:5928".parse().unwrap(), &handle).unwrap(); println!("listening on {:?}", listener.local_addr()); @@ -37,9 +36,7 @@ pub fn main() { conn.for_each(|(request, mut stream)| { println!("GOT request: {:?}", request); - let response = Response::builder() - .status(StatusCode::OK) - .body(()).unwrap(); + let response = Response::builder().status(StatusCode::OK).body(()).unwrap(); if let Err(e) = stream.send_response(response, false) { println!(" error responding; err={:?}", e); @@ -52,9 +49,10 @@ pub fn main() { Ok(()) }).and_then(|_| { - println!("~~~~~~~~~~~~~~~~~~~~~~~~~~~ H2 connection CLOSE !!!!!! ~~~~~~~~~~~"); - Ok(()) - }) + println!("~~~~~~~~~~~~~~~~~~~~~~~~~~~ H2 connection CLOSE !!!!!! \ + ~~~~~~~~~~~"); + Ok(()) + }) }) .then(|res| { if let Err(e) = res { @@ -62,8 +60,7 @@ pub fn main() { } Ok(()) - }) - ; + }); handle.spawn(connection); Ok(()) diff --git a/src/client.rs b/src/client.rs index 652cb9e..7bfab0e 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,26 +1,24 @@ -use frame::{StreamId, Headers, Pseudo, Settings}; -use frame::Reason::*; use codec::{Codec, RecvError}; +use frame::{Headers, Pseudo, Settings, StreamId}; +use frame::Reason::*; use proto::{self, Connection, WindowSize}; -use http::{Request, Response, HeaderMap}; -use futures::{Future, Poll, Sink, Async, AsyncSink, AndThen, MapErr}; +use bytes::{Bytes, IntoBuf}; +use futures::{AndThen, Async, AsyncSink, Future, MapErr, Poll, Sink}; +use http::{HeaderMap, Request, Response}; use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::io::WriteAll; -use bytes::{Bytes, IntoBuf}; use std::fmt; use std::io::Error as IoError; /// In progress H2 connection binding pub struct Handshake { - inner: - AndThen< - MapErr, fn(IoError) -> ::Error>, - Result, ::Error>, - fn((T, &'static [u8])) -> Result, ::Error> - > - + inner: AndThen< + MapErr, fn(IoError) -> ::Error>, + Result, ::Error>, + fn((T, &'static [u8])) -> Result, ::Error>, + >, } /// Marker type indicating a client peer @@ -42,7 +40,8 @@ pub struct Body { pub(crate) struct Peer; impl Client - where T: AsyncRead + AsyncWrite, +where + T: AsyncRead + AsyncWrite, { pub fn handshake(io: T) -> Handshake { Client::handshake2(io) @@ -50,8 +49,9 @@ impl Client } impl Client - where T: AsyncRead + AsyncWrite, - B: IntoBuf +where + T: AsyncRead + AsyncWrite, + B: IntoBuf, { /// Bind an H2 client connection. /// @@ -66,35 +66,36 @@ impl Client debug!("binding client connection"); let bind: fn((T, &'static [u8])) - -> Result, ::Error> = - |(io, _)| { - debug!("client connection bound"); + -> Result, ::Error> = |(io, _)| { + debug!("client connection bound"); - // Create the codec - let mut codec = Codec::new(io); + // Create the codec + let mut codec = Codec::new(io); - // Create the initial SETTINGS frame - let settings = Settings::default(); + // Create the initial SETTINGS frame + let settings = Settings::default(); - // Send initial settings frame - match codec.start_send(settings.into()) { - Ok(AsyncSink::Ready) => { - let connection = Connection::new(codec); - Ok(Client { connection }) - } - Ok(_) => unreachable!(), - Err(e) => Err(::Error::from(e)), + // Send initial settings frame + match codec.start_send(settings.into()) { + Ok(AsyncSink::Ready) => { + let connection = Connection::new(codec); + Ok(Client { + connection, + }) } - }; + Ok(_) => unreachable!(), + Err(e) => Err(::Error::from(e)), + } + }; - let msg: &'static [u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"; + let msg: &'static [u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"; let handshake = io::write_all(io, msg) - .map_err(::Error::from as - fn(IoError) -> ::Error - ) + .map_err(::Error::from as fn(IoError) -> ::Error) .and_then(bind); - Handshake { inner: handshake } + Handshake { + inner: handshake, + } } /// Returns `Ready` when the connection can initialize a new HTTP 2.0 @@ -104,36 +105,41 @@ impl Client } /// Send a request on a new HTTP 2.0 stream - pub fn request(&mut self, request: Request<()>, end_of_stream: bool) - -> Result, ::Error> - { - self.connection.send_request(request, end_of_stream) + pub fn request( + &mut self, + request: Request<()>, + end_of_stream: bool, + ) -> Result, ::Error> { + self.connection + .send_request(request, end_of_stream) .map_err(Into::into) - .map(|stream| Stream { - inner: stream, + .map(|stream| { + Stream { + inner: stream, + } }) } } impl Future for Client - // TODO: Get rid of 'static - where T: AsyncRead + AsyncWrite, - B: IntoBuf, +where + T: AsyncRead + AsyncWrite, + B: IntoBuf, { type Item = (); type Error = ::Error; fn poll(&mut self) -> Poll<(), ::Error> { - self.connection.poll() - .map_err(Into::into) + self.connection.poll().map_err(Into::into) } } impl fmt::Debug for Client - where T: AsyncRead + AsyncWrite, - T: fmt::Debug, - B: fmt::Debug + IntoBuf, - B::Buf: fmt::Debug, +where + T: AsyncRead + AsyncWrite, + T: fmt::Debug, + B: fmt::Debug + IntoBuf, + B::Buf: fmt::Debug, { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("Client") @@ -144,8 +150,9 @@ impl fmt::Debug for Client #[cfg(feature = "unstable")] impl Client - where T: AsyncRead + AsyncWrite, - B: IntoBuf +where + T: AsyncRead + AsyncWrite, + B: IntoBuf, { /// Returns the number of active streams. /// @@ -168,7 +175,9 @@ impl Client // ===== impl Handshake ===== impl Future for Handshake -where T: AsyncRead + AsyncWrite { +where + T: AsyncRead + AsyncWrite, +{ type Item = Client; type Error = ::Error; @@ -178,10 +187,11 @@ where T: AsyncRead + AsyncWrite { } impl fmt::Debug for Handshake - where T: AsyncRead + AsyncWrite, - T: fmt::Debug, - B: fmt::Debug + IntoBuf, - B::Buf: fmt::Debug + IntoBuf, +where + T: AsyncRead + AsyncWrite, + T: fmt::Debug, + B: fmt::Debug + IntoBuf, + B::Buf: fmt::Debug + IntoBuf, { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "client::Handshake") @@ -194,7 +204,9 @@ impl Stream { /// Receive the HTTP/2.0 response, if it is ready. pub fn poll_response(&mut self) -> Poll>, ::Error> { let (parts, _) = try_ready!(self.inner.poll_response()).into_parts(); - let body = Body { inner: self.inner.clone() }; + let body = Body { + inner: self.inner.clone(), + }; Ok(Response::from_parts(parts, body).into()) } @@ -217,19 +229,15 @@ impl Stream { } /// Send data - pub fn send_data(&mut self, data: B, end_of_stream: bool) - -> Result<(), ::Error> - { - self.inner.send_data(data.into_buf(), end_of_stream) + pub fn send_data(&mut self, data: B, end_of_stream: bool) -> Result<(), ::Error> { + self.inner + .send_data(data.into_buf(), end_of_stream) .map_err(Into::into) } /// Send trailers - pub fn send_trailers(&mut self, trailers: HeaderMap) - -> Result<(), ::Error> - { - self.inner.send_trailers(trailers) - .map_err(Into::into) + pub fn send_trailers(&mut self, trailers: HeaderMap) -> Result<(), ::Error> { + self.inner.send_trailers(trailers).map_err(Into::into) } } @@ -251,7 +259,8 @@ impl Body { } pub fn release_capacity(&mut self, sz: usize) -> Result<(), ::Error> { - self.inner.release_capacity(sz as proto::WindowSize) + self.inner + .release_capacity(sz as proto::WindowSize) .map_err(Into::into) } @@ -259,8 +268,7 @@ impl Body { /// /// This function **must** not be called until `Body::poll` returns `None`. pub fn poll_trailers(&mut self) -> Poll, ::Error> { - self.inner.poll_trailers() - .map_err(Into::into) + self.inner.poll_trailers().map_err(Into::into) } } @@ -269,8 +277,7 @@ impl ::futures::Stream for Body { type Error = ::Error; fn poll(&mut self) -> Poll, Self::Error> { - self.inner.poll_data() - .map_err(Into::into) + self.inner.poll_data().map_err(Into::into) } } @@ -284,14 +291,16 @@ impl proto::Peer for Peer { false } - fn convert_send_message( - id: StreamId, - request: Self::Send, - end_of_stream: bool) -> Headers - { + fn convert_send_message(id: StreamId, request: Self::Send, end_of_stream: bool) -> Headers { use http::request::Parts; - let (Parts { method, uri, headers, .. }, _) = request.into_parts(); + let (Parts { + method, + uri, + headers, + .. + }, + _) = request.into_parts(); // Build the set pseudo header set. All requests will include `method` // and `path`. @@ -323,9 +332,9 @@ impl proto::Peer for Peer { // TODO: Should there be more specialized handling for different // kinds of errors return Err(RecvError::Stream { - id: stream_id, - reason: ProtocolError, - }); + id: stream_id, + reason: ProtocolError, + }); } }; diff --git a/src/codec/error.rs b/src/codec/error.rs index bdd2621..33c753f 100644 --- a/src/codec/error.rs +++ b/src/codec/error.rs @@ -6,10 +6,7 @@ use std::{error, fmt, io}; #[derive(Debug)] pub enum RecvError { Connection(Reason), - Stream { - id: StreamId, - reason: Reason, - }, + Stream { id: StreamId, reason: Reason }, Io(io::Error), } @@ -56,7 +53,9 @@ impl error::Error for RecvError { match *self { Connection(ref reason) => reason.description(), - Stream { ref reason, .. } => reason.description(), + Stream { + ref reason, .. + } => reason.description(), Io(ref e) => e.description(), } } diff --git a/src/codec/framed_read.rs b/src/codec/framed_read.rs index 7f428cb..a184aa0 100644 --- a/src/codec/framed_read.rs +++ b/src/codec/framed_read.rs @@ -101,9 +101,9 @@ impl FramedRead { // treat this as a stream error (Section 5.4.2) of type // `PROTOCOL_ERROR`. return Err(Stream { - id: head.stream_id(), - reason: ProtocolError, - }); + id: head.stream_id(), + reason: ProtocolError, + }); } _ => return Err(Connection(ProtocolError)), }; @@ -114,9 +114,9 @@ impl FramedRead { Ok(_) => {} Err(frame::Error::MalformedMessage) => { return Err(Stream { - id: head.stream_id(), - reason: ProtocolError, - }); + id: head.stream_id(), + reason: ProtocolError, + }); } Err(_) => return Err(Connection(ProtocolError)), } @@ -125,9 +125,9 @@ impl FramedRead { } else { // Defer loading the frame self.partial = Some(Partial { - frame: Continuable::Headers(headers), - buf: payload, - }); + frame: Continuable::Headers(headers), + buf: payload, + }); return Ok(None); } @@ -157,9 +157,9 @@ impl FramedRead { // treat this as a stream error (Section 5.4.2) of type // `PROTOCOL_ERROR`. return Err(Stream { - id: head.stream_id(), - reason: ProtocolError, - }); + id: head.stream_id(), + reason: ProtocolError, + }); } Err(_) => return Err(Connection(ProtocolError)), } @@ -192,9 +192,9 @@ impl FramedRead { Ok(_) => {} Err(frame::Error::MalformedMessage) => { return Err(Stream { - id: head.stream_id(), - reason: ProtocolError, - }); + id: head.stream_id(), + reason: ProtocolError, + }); } Err(_) => return Err(Connection(ProtocolError)), } @@ -234,7 +234,8 @@ impl FramedRead { } impl Stream for FramedRead - where T: AsyncRead, +where + T: AsyncRead, { type Item = Frame; type Error = RecvError; @@ -248,7 +249,7 @@ impl Stream for FramedRead }; trace!("poll; bytes={}B", bytes.len()); - if let Some(frame) = try!(self.decode_frame(bytes)) { + if let Some(frame) = self.decode_frame(bytes)? { debug!("received; frame={:?}", frame); return Ok(Async::Ready(Some(frame))); } diff --git a/src/codec/framed_write.rs b/src/codec/framed_write.rs index 1e92100..1d298c1 100644 --- a/src/codec/framed_write.rs +++ b/src/codec/framed_write.rs @@ -3,9 +3,9 @@ use codec::UserError::*; use frame::{self, Frame, FrameSize}; use hpack; +use bytes::{Buf, BufMut, BytesMut}; use futures::*; use tokio_io::{AsyncRead, AsyncWrite}; -use bytes::{BytesMut, Buf, BufMut}; use std::io::{self, Cursor}; @@ -51,8 +51,9 @@ const CHAIN_THRESHOLD: usize = 256; // TODO: Make generic impl FramedWrite - where T: AsyncWrite, - B: Buf, +where + T: AsyncWrite, + B: Buf, { pub fn new(inner: T) -> FramedWrite { FramedWrite { @@ -72,7 +73,7 @@ impl FramedWrite pub fn poll_ready(&mut self) -> Poll<(), io::Error> { if !self.has_capacity() { // Try flushing - try!(self.flush()); + self.flush()?; if !self.has_capacity() { return Ok(Async::NotReady); @@ -248,7 +249,8 @@ impl io::Read for FramedWrite { impl AsyncRead for FramedWrite { fn read_buf(&mut self, buf: &mut B2) -> Poll - where Self: Sized, + where + Self: Sized, { self.inner.read_buf(buf) } diff --git a/src/codec/mod.rs b/src/codec/mod.rs index 3b6d499..01db79b 100644 --- a/src/codec/mod.rs +++ b/src/codec/mod.rs @@ -2,12 +2,12 @@ mod error; mod framed_read; mod framed_write; -pub use self::error::{SendError, RecvError, UserError}; +pub use self::error::{RecvError, SendError, UserError}; use self::framed_read::FramedRead; use self::framed_write::FramedWrite; -use frame::{self, Frame, Data}; +use frame::{self, Data, Frame}; use futures::*; @@ -24,16 +24,14 @@ pub struct Codec { } impl Codec - where T: AsyncRead + AsyncWrite, - B: Buf, +where + T: AsyncRead + AsyncWrite, + B: Buf, { /// Returns a new `Codec` with the default max frame size #[inline] pub fn new(io: T) -> Self { - Self::with_max_recv_frame_size( - io, - frame::DEFAULT_MAX_FRAME_SIZE as usize - ) + Self::with_max_recv_frame_size(io, frame::DEFAULT_MAX_FRAME_SIZE as usize) } /// Returns a new `Codec` with the given maximum frame size @@ -52,12 +50,13 @@ impl Codec let inner = FramedRead::new(delimited); - Codec { inner } + Codec { + inner, + } } } impl Codec { - /// Updates the max received frame size. /// /// The change takes effect the next time a frame is decoded. In other @@ -68,7 +67,6 @@ impl Codec { pub fn set_max_recv_frame_size(&mut self, val: usize) { // TODO: should probably make some assertions about max frame size... self.inner.set_max_frame_size(val) - } /// Returns the current max received frame size setting. @@ -112,8 +110,9 @@ impl Codec { } impl Codec - where T: AsyncWrite, - B: Buf, +where + T: AsyncWrite, + B: Buf, { /// Returns `Ready` when the codec can buffer a frame pub fn poll_ready(&mut self) -> Poll<(), io::Error> { @@ -126,8 +125,7 @@ impl Codec /// accepted. /// /// TODO: Rename this to avoid conflicts with Sink::buffer - pub fn buffer(&mut self, item: Frame) -> Result<(), UserError> - { + pub fn buffer(&mut self, item: Frame) -> Result<(), UserError> { self.framed_write().buffer(item) } @@ -143,7 +141,8 @@ impl Codec } impl Stream for Codec - where T: AsyncRead, +where + T: AsyncRead, { type Item = Frame; type Error = RecvError; @@ -154,8 +153,9 @@ impl Stream for Codec } impl Sink for Codec - where T: AsyncWrite, - B: Buf, +where + T: AsyncWrite, + B: Buf, { type SinkItem = Frame; type SinkError = SendError; @@ -182,7 +182,8 @@ impl Sink for Codec // TODO: remove (or improve) this impl From for Codec> - where T: AsyncRead + AsyncWrite, +where + T: AsyncRead + AsyncWrite, { fn from(src: T) -> Self { Self::new(src) diff --git a/src/error.rs b/src/error.rs index 3488dbd..c004dcd 100644 --- a/src/error.rs +++ b/src/error.rs @@ -44,13 +44,17 @@ impl From for Error { impl From for Error { fn from(src: io::Error) -> Error { - Error { kind: Kind::Io(src) } + Error { + kind: Kind::Io(src), + } } } impl From for Error { fn from(src: Reason) -> Error { - Error { kind: Kind::Proto(src) } + Error { + kind: Kind::Proto(src), + } } } @@ -65,7 +69,9 @@ impl From for Error { impl From for Error { fn from(src: UserError) -> Error { - Error { kind: Kind::User(src) } + Error { + kind: Kind::User(src), + } } } diff --git a/src/frame/data.rs b/src/frame/data.rs index b627ce3..71bdad7 100644 --- a/src/frame/data.rs +++ b/src/frame/data.rs @@ -1,5 +1,5 @@ -use frame::{util, Frame, Head, Error, StreamId, Kind}; -use bytes::{BufMut, Bytes, Buf}; +use bytes::{Buf, BufMut, Bytes}; +use frame::{util, Error, Frame, Head, Kind, StreamId}; use std::fmt; @@ -92,7 +92,8 @@ impl Data { } pub(crate) fn map(self, f: F) -> Data - where F: FnOnce(T) -> U, + where + F: FnOnce(T) -> U, { Data { stream_id: self.stream_id, @@ -120,11 +121,11 @@ impl Data { }; Ok(Data { - stream_id: head.stream_id(), - data: payload, - flags: flags, - pad_len: pad_len, - }) + stream_id: head.stream_id(), + data: payload, + flags: flags, + pad_len: pad_len, + }) } } diff --git a/src/frame/go_away.rs b/src/frame/go_away.rs index 0b16779..b1dbd8c 100644 --- a/src/frame/go_away.rs +++ b/src/frame/go_away.rs @@ -1,6 +1,6 @@ -use frame::{self, Head, Error, Kind, StreamId, Reason}; +use frame::{self, Error, Head, Kind, Reason, StreamId}; -use bytes::{BufMut, BigEndian}; +use bytes::{BigEndian, BufMut}; #[derive(Debug, Clone, Copy, Eq, PartialEq)] pub struct GoAway { @@ -35,9 +35,9 @@ impl GoAway { let error_code = unpack_octets_4!(payload, 4, u32); Ok(GoAway { - last_stream_id: last_stream_id, - error_code: error_code, - }) + last_stream_id: last_stream_id, + error_code: error_code, + }) } pub fn encode(&self, dst: &mut B) { diff --git a/src/frame/head.rs b/src/frame/head.rs index 28caad0..7050c6e 100644 --- a/src/frame/head.rs +++ b/src/frame/head.rs @@ -1,6 +1,6 @@ use super::StreamId; -use bytes::{BufMut, BigEndian}; +use bytes::{BigEndian, BufMut}; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub struct Head { diff --git a/src/frame/headers.rs b/src/frame/headers.rs index e44a9aa..f6b460b 100644 --- a/src/frame/headers.rs +++ b/src/frame/headers.rs @@ -1,12 +1,12 @@ -use super::{StreamId, StreamDependency}; +use super::{StreamDependency, StreamId}; +use frame::{self, Error, Frame, Head, Kind}; use hpack; -use frame::{self, Frame, Head, Kind, Error}; -use http::{uri, Method, StatusCode, Uri, HeaderMap}; +use http::{uri, HeaderMap, Method, StatusCode, Uri}; use http::header::{self, HeaderName, HeaderValue}; -use bytes::{BytesMut, Bytes}; use byteorder::{BigEndian, ByteOrder}; +use bytes::{Bytes, BytesMut}; use string::String; use std::fmt; @@ -89,10 +89,7 @@ const END_STREAM: u8 = 0x1; const END_HEADERS: u8 = 0x4; const PADDED: u8 = 0x8; const PRIORITY: u8 = 0x20; -const ALL: u8 = END_STREAM - | END_HEADERS - | PADDED - | PRIORITY; +const ALL: u8 = END_STREAM | END_HEADERS | PADDED | PRIORITY; // ===== impl Headers ===== @@ -124,9 +121,7 @@ impl Headers { /// Loads the header frame but doesn't actually do HPACK decoding. /// /// HPACK decoding is done in the `load_hpack` step. - pub fn load(head: Head, mut src: BytesMut) - -> Result<(Self, BytesMut), Error> - { + pub fn load(head: Head, mut src: BytesMut) -> Result<(Self, BytesMut), Error> { let flags = HeadersFlag(head.flag()); let mut pad = 0; @@ -177,11 +172,7 @@ impl Headers { Ok((headers, src)) } - pub fn load_hpack(&mut self, - src: BytesMut, - decoder: &mut hpack::Decoder) - -> Result<(), Error> - { + pub fn load_hpack(&mut self, src: BytesMut, decoder: &mut hpack::Decoder) -> Result<(), Error> { let mut reg = false; let mut malformed = false; @@ -210,7 +201,10 @@ impl Headers { use hpack::Header::*; match header { - Field { name, value } => { + Field { + name, + value, + } => { // Connection level header fields are not supported and must // result in a protocol error. @@ -274,9 +268,7 @@ impl Headers { self.fields } - pub fn encode(self, encoder: &mut hpack::Encoder, dst: &mut BytesMut) - -> Option - { + pub fn encode(self, encoder: &mut hpack::Encoder, dst: &mut BytesMut) -> Option { let head = self.head(); let pos = dst.len(); @@ -295,10 +287,10 @@ impl Headers { hpack::Encode::Full => None, hpack::Encode::Partial(state) => { Some(Continuation { - stream_id: self.stream_id, - hpack: state, - headers: headers, - }) + stream_id: self.stream_id, + hpack: state, + headers: headers, + }) } }; @@ -306,7 +298,7 @@ impl Headers { let len = (dst.len() - pos) - frame::HEADER_LEN; // Write the frame length - BigEndian::write_uint(&mut dst[pos..pos+3], len as u64, 3); + BigEndian::write_uint(&mut dst[pos..pos + 3], len as u64, 3); ret } @@ -336,9 +328,7 @@ impl fmt::Debug for Headers { // ===== impl PushPromise ===== impl PushPromise { - pub fn load(head: Head, payload: &[u8]) - -> Result - { + pub fn load(head: Head, payload: &[u8]) -> Result { let flags = PushPromiseFlag(head.flag()); // TODO: Handle padding @@ -346,10 +336,10 @@ impl PushPromise { let (promised_id, _) = StreamId::parse(&payload[..4]); Ok(PushPromise { - stream_id: head.stream_id(), - promised_id: promised_id, - flags: flags, - }) + stream_id: head.stream_id(), + promised_id: promised_id, + flags: flags, + }) } pub fn stream_id(&self) -> StreamId { @@ -377,7 +367,8 @@ impl Pseudo { unsafe { String::from_utf8_unchecked(src) } } - let path = parts.path_and_query + let path = parts + .path_and_query .map(|v| v.into()) .unwrap_or_else(|| Bytes::from_static(b"/")); @@ -456,10 +447,12 @@ impl Iterator for Iter { self.pseudo = None; - self.fields.next() - .map(|(name, value)| { - Field { name: name, value: value} - }) + self.fields.next().map(|(name, value)| { + Field { + name: name, + value: value, + } + }) } } diff --git a/src/frame/mod.rs b/src/frame/mod.rs index 69ac0c5..cecb974 100644 --- a/src/frame/mod.rs +++ b/src/frame/mod.rs @@ -42,7 +42,7 @@ mod window_update; pub use self::data::Data; pub use self::go_away::GoAway; pub use self::head::{Head, Kind}; -pub use self::headers::{Headers, PushPromise, Continuation, Pseudo}; +pub use self::headers::{Continuation, Headers, Pseudo, PushPromise}; pub use self::ping::Ping; pub use self::priority::{Priority, StreamDependency}; pub use self::reason::Reason; @@ -52,10 +52,11 @@ pub use self::stream_id::StreamId; pub use self::window_update::WindowUpdate; // Re-export some constants + pub use self::settings::{ - DEFAULT_SETTINGS_HEADER_TABLE_SIZE, DEFAULT_INITIAL_WINDOW_SIZE, DEFAULT_MAX_FRAME_SIZE, + DEFAULT_SETTINGS_HEADER_TABLE_SIZE, MAX_INITIAL_WINDOW_SIZE, MAX_MAX_FRAME_SIZE, }; @@ -74,12 +75,13 @@ pub enum Frame { Ping(Ping), GoAway(GoAway), WindowUpdate(WindowUpdate), - Reset(Reset) + Reset(Reset), } impl Frame { pub fn map(self, f: F) -> Frame - where F: FnOnce(T) -> U + where + F: FnOnce(T) -> U, { use self::Frame::*; diff --git a/src/frame/ping.rs b/src/frame/ping.rs index 32bad8c..ba0d4c9 100644 --- a/src/frame/ping.rs +++ b/src/frame/ping.rs @@ -1,5 +1,5 @@ use bytes::{Buf, BufMut, IntoBuf}; -use frame::{Frame, Head, Kind, Error, StreamId}; +use frame::{Error, Frame, Head, Kind, StreamId}; const ACK_FLAG: u8 = 0x1; @@ -21,7 +21,10 @@ impl Ping { } pub fn pong(payload: Payload) -> Ping { - Ping { ack: true, payload } + Ping { + ack: true, + payload, + } } pub fn is_ack(&self) -> bool { @@ -65,7 +68,10 @@ impl Ping { // endpoint MUST NOT respond to PING frames containing this flag. let ack = head.flag() & ACK_FLAG != 0; - Ok(Ping { ack, payload }) + Ok(Ping { + ack, + payload, + }) } pub fn encode(&self, dst: &mut B) { diff --git a/src/frame/priority.rs b/src/frame/priority.rs index cb23795..16d9494 100644 --- a/src/frame/priority.rs +++ b/src/frame/priority.rs @@ -29,9 +29,9 @@ impl Priority { } Ok(Priority { - stream_id: head.stream_id(), - dependency: dependency, - }) + stream_id: head.stream_id(), + dependency: dependency, + }) } } @@ -63,10 +63,7 @@ impl StreamDependency { // Read the weight let weight = src[4]; - Ok(StreamDependency::new( - dependency_id, - weight, - is_exclusive)) + Ok(StreamDependency::new(dependency_id, weight, is_exclusive)) } pub fn dependency_id(&self) -> StreamId { diff --git a/src/frame/reason.rs b/src/frame/reason.rs index 894cd87..a2f6440 100644 --- a/src/frame/reason.rs +++ b/src/frame/reason.rs @@ -37,7 +37,10 @@ impl Reason { RefusedStream => "refused stream before processing any application logic", Cancel => "stream no longer needed", CompressionError => "unable to maintain the header compression context", - ConnectError => "connection established in response to a CONNECT request was reset or abnormally closed", + ConnectError => { + "connection established in response to a CONNECT request \ + was reset or abnormally closed" + } EnhanceYourCalm => "detected excessive load generating behavior", InadequateSecurity => "security properties do not meet minimum requirements", Http11Required => "endpoint requires HTTP/1.1", diff --git a/src/frame/reset.rs b/src/frame/reset.rs index 37a4533..d82f401 100644 --- a/src/frame/reset.rs +++ b/src/frame/reset.rs @@ -1,6 +1,6 @@ -use frame::{self, Head, Error, Kind, StreamId, Reason}; +use frame::{self, Error, Head, Kind, Reason, StreamId}; -use bytes::{BufMut, BigEndian}; +use bytes::{BigEndian, BufMut}; #[derive(Debug, Eq, PartialEq)] pub struct Reset { @@ -32,13 +32,15 @@ impl Reset { let error_code = unpack_octets_4!(payload, 0, u32); Ok(Reset { - stream_id: head.stream_id(), - error_code: error_code, - }) + stream_id: head.stream_id(), + error_code: error_code, + }) } pub fn encode(&self, dst: &mut B) { - trace!("encoding RESET; id={:?} code={}", self.stream_id, self.error_code); + trace!("encoding RESET; id={:?} code={}", + self.stream_id, + self.error_code); let head = Head::new(Kind::Reset, 0, self.stream_id); head.encode(4, dst); dst.put_u32::(self.error_code); diff --git a/src/frame/settings.rs b/src/frame/settings.rs index b4ae32f..81f9409 100644 --- a/src/frame/settings.rs +++ b/src/frame/settings.rs @@ -1,5 +1,5 @@ -use frame::{Frame, FrameSize, Error, Head, Kind, StreamId}; -use bytes::{BytesMut, BufMut, BigEndian}; +use bytes::{BigEndian, BufMut, BytesMut}; +use frame::{Error, Frame, FrameSize, Head, Kind, StreamId}; #[derive(Debug, Clone, Default, Eq, PartialEq)] pub struct Settings { @@ -54,7 +54,7 @@ impl Settings { pub fn ack() -> Settings { Settings { flags: SettingsFlags::ack(), - .. Settings::default() + ..Settings::default() } } diff --git a/src/frame/window_update.rs b/src/frame/window_update.rs index b6ba7b8..6bfaed6 100644 --- a/src/frame/window_update.rs +++ b/src/frame/window_update.rs @@ -1,6 +1,6 @@ -use frame::{self, Head, Kind, Error, StreamId}; +use frame::{self, Error, Head, Kind, StreamId}; -use bytes::{BufMut, BigEndian}; +use bytes::{BigEndian, BufMut}; const SIZE_INCREMENT_MASK: u32 = 1 << 31; @@ -42,9 +42,9 @@ impl WindowUpdate { } Ok(WindowUpdate { - stream_id: head.stream_id(), - size_increment, - }) + stream_id: head.stream_id(), + size_increment, + }) } pub fn encode(&self, dst: &mut B) { diff --git a/src/hpack/decoder.rs b/src/hpack/decoder.rs index 0608fa4..b8e08cc 100644 --- a/src/hpack/decoder.rs +++ b/src/hpack/decoder.rs @@ -1,15 +1,15 @@ use super::{huffman, Header}; use frame; -use http::{header}; +use bytes::{Buf, Bytes, BytesMut}; +use http::header; use http::method::{self, Method}; use http::status::{self, StatusCode}; -use bytes::{Buf, Bytes, BytesMut}; use string::String; use std::cmp; -use std::io::Cursor; use std::collections::VecDeque; +use std::io::Cursor; use std::str::Utf8Error; /// Decodes headers using HPACK @@ -164,7 +164,8 @@ impl Decoder { /// Decodes the headers found in the given buffer. pub fn decode(&mut self, src: &mut Cursor, mut f: F) -> Result<(), DecoderError> - where F: FnMut(Header) + where + F: FnMut(Header), { use self::Representation::*; @@ -180,16 +181,16 @@ impl Decoder { // At this point we are always at the beginning of the next block // within the HPACK data. The type of the block can always be // determined from the first byte. - match try!(Representation::load(peek_u8(src))) { + match Representation::load(peek_u8(src))? { Indexed => { trace!(" Indexed; rem={:?}", src.remaining()); can_resize = false; - f(try!(self.decode_indexed(src))); + f(self.decode_indexed(src)?); } LiteralWithIndexing => { trace!(" LiteralWithIndexing; rem={:?}", src.remaining()); can_resize = false; - let entry = try!(self.decode_literal(src, true)); + let entry = self.decode_literal(src, true)?; // Insert the header into the table self.table.insert(entry.clone()); @@ -199,13 +200,13 @@ impl Decoder { LiteralWithoutIndexing => { trace!(" LiteralWithoutIndexing; rem={:?}", src.remaining()); can_resize = false; - let entry = try!(self.decode_literal(src, false)); + let entry = self.decode_literal(src, false)?; f(entry); } LiteralNeverIndexed => { trace!(" LiteralNeverIndexed; rem={:?}", src.remaining()); can_resize = false; - let entry = try!(self.decode_literal(src, false)); + let entry = self.decode_literal(src, false)?; // TODO: Track that this should never be indexed @@ -218,7 +219,7 @@ impl Decoder { } // Handle the dynamic table size update - try!(self.process_size_update(src)); + self.process_size_update(src)?; } } } @@ -226,52 +227,47 @@ impl Decoder { Ok(()) } - fn process_size_update(&mut self, buf: &mut Cursor) - -> Result<(), DecoderError> - { - let new_size = try!(decode_int(buf, 5)); + fn process_size_update(&mut self, buf: &mut Cursor) -> Result<(), DecoderError> { + let new_size = decode_int(buf, 5)?; if new_size > self.last_max_update { return Err(DecoderError::InvalidMaxDynamicSize); } debug!("Decoder changed max table size from {} to {}", - self.table.size(), new_size); + self.table.size(), + new_size); self.table.set_max_size(new_size); Ok(()) } - fn decode_indexed(&self, buf: &mut Cursor) - -> Result - { - let index = try!(decode_int(buf, 7)); + fn decode_indexed(&self, buf: &mut Cursor) -> Result { + let index = decode_int(buf, 7)?; self.table.get(index) } - fn decode_literal(&mut self, buf: &mut Cursor, index: bool) - -> Result - { - let prefix = if index { - 6 - } else { - 4 - }; + fn decode_literal( + &mut self, + buf: &mut Cursor, + index: bool, + ) -> Result { + let prefix = if index { 6 } else { 4 }; // Extract the table index for the name, or 0 if not indexed - let table_idx = try!(decode_int(buf, prefix)); + let table_idx = decode_int(buf, prefix)?; // First, read the header name if table_idx == 0 { // Read the name as a literal - let name = try!(self.decode_string(buf)); - let value = try!(self.decode_string(buf)); + let name = self.decode_string(buf)?; + let value = self.decode_string(buf)?; Header::new(name, value) } else { - let e = try!(self.table.get(table_idx)); - let value = try!(self.decode_string(buf)); + let e = self.table.get(table_idx)?; + let value = self.decode_string(buf)?; e.name().into_entry(value) } @@ -288,10 +284,12 @@ impl Decoder { let huff = peek_u8(buf) & HUFF_FLAG == HUFF_FLAG; // Decode the string length using 7 bit prefix - let len = try!(decode_int(buf, 7)); + let len = decode_int(buf, 7)?; if len > buf.remaining() { - trace!("decode_string underflow; len={}; remaining={}", len, buf.remaining()); + trace!("decode_string underflow; len={}; remaining={}", + len, + buf.remaining()); return Err(DecoderError::StringUnderflow); } @@ -319,12 +317,12 @@ impl Default for Decoder { impl Representation { pub fn load(byte: u8) -> Result { - const INDEXED: u8 = 0b10000000; - const LITERAL_WITH_INDEXING: u8 = 0b01000000; + const INDEXED: u8 = 0b10000000; + const LITERAL_WITH_INDEXING: u8 = 0b01000000; const LITERAL_WITHOUT_INDEXING: u8 = 0b11110000; - const LITERAL_NEVER_INDEXED: u8 = 0b00010000; - const SIZE_UPDATE_MASK: u8 = 0b11100000; - const SIZE_UPDATE: u8 = 0b00100000; + const LITERAL_NEVER_INDEXED: u8 = 0b00010000; + const SIZE_UPDATE_MASK: u8 = 0b11100000; + const SIZE_UPDATE: u8 = 0b00100000; // TODO: What did I even write here? @@ -474,7 +472,8 @@ impl Table { debug_assert!(size <= self.max_size); while self.size + size > self.max_size { - let last = self.entries.pop_back() + let last = self.entries + .pop_back() .expect("size of table != 0, but no headers left!"); self.size -= last.len(); @@ -564,194 +563,288 @@ pub fn get_static(idx: usize) -> Header { 12 => Header::Status(StatusCode::BAD_REQUEST), 13 => Header::Status(StatusCode::NOT_FOUND), 14 => Header::Status(StatusCode::INTERNAL_SERVER_ERROR), - 15 => Header::Field { - name: header::ACCEPT_CHARSET, - value: HeaderValue::from_static(""), - }, - 16 => Header::Field { - name: header::ACCEPT_ENCODING, - value: HeaderValue::from_static("gzip, deflate"), - }, - 17 => Header::Field { - name: header::ACCEPT_LANGUAGE, - value: HeaderValue::from_static(""), - }, - 18 => Header::Field { - name: header::ACCEPT_RANGES, - value: HeaderValue::from_static(""), - }, - 19 => Header::Field { - name: header::ACCEPT, - value: HeaderValue::from_static(""), - }, - 20 => Header::Field { - name: header::ACCESS_CONTROL_ALLOW_ORIGIN, - value: HeaderValue::from_static(""), - }, - 21 => Header::Field { - name: header::AGE, - value: HeaderValue::from_static(""), - }, - 22 => Header::Field { - name: header::ALLOW, - value: HeaderValue::from_static(""), - }, - 23 => Header::Field { - name: header::AUTHORIZATION, - value: HeaderValue::from_static(""), - }, - 24 => Header::Field { - name: header::CACHE_CONTROL, - value: HeaderValue::from_static(""), - }, - 25 => Header::Field { - name: header::CONTENT_DISPOSITION, - value: HeaderValue::from_static(""), - }, - 26 => Header::Field { - name: header::CONTENT_ENCODING, - value: HeaderValue::from_static(""), - }, - 27 => Header::Field { - name: header::CONTENT_LANGUAGE, - value: HeaderValue::from_static(""), - }, - 28 => Header::Field { - name: header::CONTENT_LENGTH, - value: HeaderValue::from_static(""), - }, - 29 => Header::Field { - name: header::CONTENT_LOCATION, - value: HeaderValue::from_static(""), - }, - 30 => Header::Field { - name: header::CONTENT_RANGE, - value: HeaderValue::from_static(""), - }, - 31 => Header::Field { - name: header::CONTENT_TYPE, - value: HeaderValue::from_static(""), - }, - 32 => Header::Field { - name: header::COOKIE, - value: HeaderValue::from_static(""), - }, - 33 => Header::Field { - name: header::DATE, - value: HeaderValue::from_static(""), - }, - 34 => Header::Field { - name: header::ETAG, - value: HeaderValue::from_static(""), - }, - 35 => Header::Field { - name: header::EXPECT, - value: HeaderValue::from_static(""), - }, - 36 => Header::Field { - name: header::EXPIRES, - value: HeaderValue::from_static(""), - }, - 37 => Header::Field { - name: header::FROM, - value: HeaderValue::from_static(""), - }, - 38 => Header::Field { - name: header::HOST, - value: HeaderValue::from_static(""), - }, - 39 => Header::Field { - name: header::IF_MATCH, - value: HeaderValue::from_static(""), - }, - 40 => Header::Field { - name: header::IF_MODIFIED_SINCE, - value: HeaderValue::from_static(""), - }, - 41 => Header::Field { - name: header::IF_NONE_MATCH, - value: HeaderValue::from_static(""), - }, - 42 => Header::Field { - name: header::IF_RANGE, - value: HeaderValue::from_static(""), - }, - 43 => Header::Field { - name: header::IF_UNMODIFIED_SINCE, - value: HeaderValue::from_static(""), - }, - 44 => Header::Field { - name: header::LAST_MODIFIED, - value: HeaderValue::from_static(""), - }, - 45 => Header::Field { - name: header::LINK, - value: HeaderValue::from_static(""), - }, - 46 => Header::Field { - name: header::LOCATION, - value: HeaderValue::from_static(""), - }, - 47 => Header::Field { - name: header::MAX_FORWARDS, - value: HeaderValue::from_static(""), - }, - 48 => Header::Field { - name: header::PROXY_AUTHENTICATE, - value: HeaderValue::from_static(""), - }, - 49 => Header::Field { - name: header::PROXY_AUTHORIZATION, - value: HeaderValue::from_static(""), - }, - 50 => Header::Field { - name: header::RANGE, - value: HeaderValue::from_static(""), - }, - 51 => Header::Field { - name: header::REFERER, - value: HeaderValue::from_static(""), - }, - 52 => Header::Field { - name: header::REFRESH, - value: HeaderValue::from_static(""), - }, - 53 => Header::Field { - name: header::RETRY_AFTER, - value: HeaderValue::from_static(""), - }, - 54 => Header::Field { - name: header::SERVER, - value: HeaderValue::from_static(""), - }, - 55 => Header::Field { - name: header::SET_COOKIE, - value: HeaderValue::from_static(""), - }, - 56 => Header::Field { - name: header::STRICT_TRANSPORT_SECURITY, - value: HeaderValue::from_static(""), - }, - 57 => Header::Field { - name: header::TRANSFER_ENCODING, - value: HeaderValue::from_static(""), - }, - 58 => Header::Field { - name: header::USER_AGENT, - value: HeaderValue::from_static(""), - }, - 59 => Header::Field { - name: header::VARY, - value: HeaderValue::from_static(""), - }, - 60 => Header::Field { - name: header::VIA, - value: HeaderValue::from_static(""), - }, - 61 => Header::Field { - name: header::WWW_AUTHENTICATE, - value: HeaderValue::from_static(""), - }, + 15 => { + Header::Field { + name: header::ACCEPT_CHARSET, + value: HeaderValue::from_static(""), + } + } + 16 => { + Header::Field { + name: header::ACCEPT_ENCODING, + value: HeaderValue::from_static("gzip, deflate"), + } + } + 17 => { + Header::Field { + name: header::ACCEPT_LANGUAGE, + value: HeaderValue::from_static(""), + } + } + 18 => { + Header::Field { + name: header::ACCEPT_RANGES, + value: HeaderValue::from_static(""), + } + } + 19 => { + Header::Field { + name: header::ACCEPT, + value: HeaderValue::from_static(""), + } + } + 20 => { + Header::Field { + name: header::ACCESS_CONTROL_ALLOW_ORIGIN, + value: HeaderValue::from_static(""), + } + } + 21 => { + Header::Field { + name: header::AGE, + value: HeaderValue::from_static(""), + } + } + 22 => { + Header::Field { + name: header::ALLOW, + value: HeaderValue::from_static(""), + } + } + 23 => { + Header::Field { + name: header::AUTHORIZATION, + value: HeaderValue::from_static(""), + } + } + 24 => { + Header::Field { + name: header::CACHE_CONTROL, + value: HeaderValue::from_static(""), + } + } + 25 => { + Header::Field { + name: header::CONTENT_DISPOSITION, + value: HeaderValue::from_static(""), + } + } + 26 => { + Header::Field { + name: header::CONTENT_ENCODING, + value: HeaderValue::from_static(""), + } + } + 27 => { + Header::Field { + name: header::CONTENT_LANGUAGE, + value: HeaderValue::from_static(""), + } + } + 28 => { + Header::Field { + name: header::CONTENT_LENGTH, + value: HeaderValue::from_static(""), + } + } + 29 => { + Header::Field { + name: header::CONTENT_LOCATION, + value: HeaderValue::from_static(""), + } + } + 30 => { + Header::Field { + name: header::CONTENT_RANGE, + value: HeaderValue::from_static(""), + } + } + 31 => { + Header::Field { + name: header::CONTENT_TYPE, + value: HeaderValue::from_static(""), + } + } + 32 => { + Header::Field { + name: header::COOKIE, + value: HeaderValue::from_static(""), + } + } + 33 => { + Header::Field { + name: header::DATE, + value: HeaderValue::from_static(""), + } + } + 34 => { + Header::Field { + name: header::ETAG, + value: HeaderValue::from_static(""), + } + } + 35 => { + Header::Field { + name: header::EXPECT, + value: HeaderValue::from_static(""), + } + } + 36 => { + Header::Field { + name: header::EXPIRES, + value: HeaderValue::from_static(""), + } + } + 37 => { + Header::Field { + name: header::FROM, + value: HeaderValue::from_static(""), + } + } + 38 => { + Header::Field { + name: header::HOST, + value: HeaderValue::from_static(""), + } + } + 39 => { + Header::Field { + name: header::IF_MATCH, + value: HeaderValue::from_static(""), + } + } + 40 => { + Header::Field { + name: header::IF_MODIFIED_SINCE, + value: HeaderValue::from_static(""), + } + } + 41 => { + Header::Field { + name: header::IF_NONE_MATCH, + value: HeaderValue::from_static(""), + } + } + 42 => { + Header::Field { + name: header::IF_RANGE, + value: HeaderValue::from_static(""), + } + } + 43 => { + Header::Field { + name: header::IF_UNMODIFIED_SINCE, + value: HeaderValue::from_static(""), + } + } + 44 => { + Header::Field { + name: header::LAST_MODIFIED, + value: HeaderValue::from_static(""), + } + } + 45 => { + Header::Field { + name: header::LINK, + value: HeaderValue::from_static(""), + } + } + 46 => { + Header::Field { + name: header::LOCATION, + value: HeaderValue::from_static(""), + } + } + 47 => { + Header::Field { + name: header::MAX_FORWARDS, + value: HeaderValue::from_static(""), + } + } + 48 => { + Header::Field { + name: header::PROXY_AUTHENTICATE, + value: HeaderValue::from_static(""), + } + } + 49 => { + Header::Field { + name: header::PROXY_AUTHORIZATION, + value: HeaderValue::from_static(""), + } + } + 50 => { + Header::Field { + name: header::RANGE, + value: HeaderValue::from_static(""), + } + } + 51 => { + Header::Field { + name: header::REFERER, + value: HeaderValue::from_static(""), + } + } + 52 => { + Header::Field { + name: header::REFRESH, + value: HeaderValue::from_static(""), + } + } + 53 => { + Header::Field { + name: header::RETRY_AFTER, + value: HeaderValue::from_static(""), + } + } + 54 => { + Header::Field { + name: header::SERVER, + value: HeaderValue::from_static(""), + } + } + 55 => { + Header::Field { + name: header::SET_COOKIE, + value: HeaderValue::from_static(""), + } + } + 56 => { + Header::Field { + name: header::STRICT_TRANSPORT_SECURITY, + value: HeaderValue::from_static(""), + } + } + 57 => { + Header::Field { + name: header::TRANSFER_ENCODING, + value: HeaderValue::from_static(""), + } + } + 58 => { + Header::Field { + name: header::USER_AGENT, + value: HeaderValue::from_static(""), + } + } + 59 => { + Header::Field { + name: header::VARY, + value: HeaderValue::from_static(""), + } + } + 60 => { + Header::Field { + name: header::VIA, + value: HeaderValue::from_static(""), + } + } + 61 => { + Header::Field { + name: header::WWW_AUTHENTICATE, + value: HeaderValue::from_static(""), + } + } _ => unreachable!(), } } diff --git a/src/hpack/encoder.rs b/src/hpack/encoder.rs index 8e6d8e9..2818486 100644 --- a/src/hpack/encoder.rs +++ b/src/hpack/encoder.rs @@ -1,8 +1,8 @@ use super::{huffman, Header}; -use super::table::{Table, Index}; +use super::table::{Index, Table}; +use bytes::{BufMut, BytesMut}; use http::header::{HeaderName, HeaderValue}; -use bytes::{BytesMut, BufMut}; #[derive(Debug)] pub struct Encoder { @@ -76,9 +76,14 @@ impl Encoder { } /// Encode a set of headers into the provide buffer - pub fn encode(&mut self, resume: Option, headers: &mut I, dst: &mut BytesMut) - -> Encode - where I: Iterator>>, + pub fn encode( + &mut self, + resume: Option, + headers: &mut I, + dst: &mut BytesMut, + ) -> Encode + where + I: Iterator>>, { let len = dst.len(); @@ -94,15 +99,8 @@ impl Encoder { let len = dst.len(); let res = match resume.value { - Some(ref value) => { - self.encode_header_without_name( - &resume.index, - value, - dst) - } - None => { - self.encode_header(&resume.index, dst) - } + Some(ref value) => self.encode_header_without_name(&resume.index, value, dst), + None => self.encode_header(&resume.index, dst), }; if res.is_err() { @@ -126,9 +124,9 @@ impl Encoder { if res.is_err() { dst.truncate(len); return Encode::Partial(EncodeState { - index: index, - value: None, - }); + index: index, + value: None, + }); } last_index = Some(index); @@ -138,17 +136,15 @@ impl Encoder { // which case, we skip table lookup and just use the same index // as the previous entry. Err(value) => { - let res = self.encode_header_without_name( - last_index.as_ref().unwrap(), - &value, - dst); + let res = + self.encode_header_without_name(last_index.as_ref().unwrap(), &value, dst); if res.is_err() { dst.truncate(len); return Encode::Partial(EncodeState { - index: last_index.unwrap(), - value: Some(value), - }); + index: last_index.unwrap(), + value: Some(value), + }); } } }; @@ -161,13 +157,13 @@ impl Encoder { match self.size_update.take() { Some(SizeUpdate::One(val)) => { self.table.resize(val); - try!(encode_size_update(val, dst)); + encode_size_update(val, dst)?; } Some(SizeUpdate::Two(min, max)) => { self.table.resize(min); self.table.resize(max); - try!(encode_size_update(min, dst)); - try!(encode_size_update(max, dst)); + encode_size_update(min, dst)?; + encode_size_update(max, dst)?; } None => {} } @@ -175,21 +171,15 @@ impl Encoder { Ok(()) } - fn encode_header(&mut self, index: &Index, dst: &mut BytesMut) - -> Result<(), EncoderError> - { + fn encode_header(&mut self, index: &Index, dst: &mut BytesMut) -> Result<(), EncoderError> { match *index { Index::Indexed(idx, _) => { - try!(encode_int(idx, 7, 0x80, dst)); + encode_int(idx, 7, 0x80, dst)?; } Index::Name(idx, _) => { let header = self.table.resolve(&index); - try!(encode_not_indexed( - idx, - header.value_slice(), - header.is_sensitive(), - dst)); + encode_not_indexed(idx, header.value_slice(), header.is_sensitive(), dst)?; } Index::Inserted(_) => { let header = self.table.resolve(&index); @@ -202,57 +192,52 @@ impl Encoder { dst.put_u8(0b01000000); - try!(encode_str(header.name().as_slice(), dst)); - try!(encode_str(header.value_slice(), dst)); + encode_str(header.name().as_slice(), dst)?; + encode_str(header.value_slice(), dst)?; } Index::InsertedValue(idx, _) => { let header = self.table.resolve(&index); assert!(!header.is_sensitive()); - try!(encode_int(idx, 6, 0b01000000, dst)); - try!(encode_str(header.value_slice(), dst)); + encode_int(idx, 6, 0b01000000, dst)?; + encode_str(header.value_slice(), dst)?; } Index::NotIndexed(_) => { let header = self.table.resolve(&index); - try!(encode_not_indexed2( - header.name().as_slice(), - header.value_slice(), - header.is_sensitive(), - dst)); + encode_not_indexed2(header.name().as_slice(), + header.value_slice(), + header.is_sensitive(), + dst)?; } } Ok(()) } - fn encode_header_without_name(&mut self, last: &Index, - value: &HeaderValue, dst: &mut BytesMut) - -> Result<(), EncoderError> - { + fn encode_header_without_name( + &mut self, + last: &Index, + value: &HeaderValue, + dst: &mut BytesMut, + ) -> Result<(), EncoderError> { match *last { Index::Indexed(..) | - Index::Name(..) | - Index::Inserted(..) | - Index::InsertedValue(..) => - { + Index::Name(..) | + Index::Inserted(..) | + Index::InsertedValue(..) => { let idx = self.table.resolve_idx(last); - try!(encode_not_indexed( - idx, - value.as_ref(), - value.is_sensitive(), - dst)); + encode_not_indexed(idx, value.as_ref(), value.is_sensitive(), dst)?; } Index::NotIndexed(_) => { let last = self.table.resolve(last); - try!(encode_not_indexed2( - last.name().as_slice(), - value.as_ref(), - value.is_sensitive(), - dst)); + encode_not_indexed2(last.name().as_slice(), + value.as_ref(), + value.is_sensitive(), + dst)?; } } @@ -270,24 +255,28 @@ fn encode_size_update(val: usize, dst: &mut B) -> Result<(), EncoderE encode_int(val, 5, 0b00100000, dst) } -fn encode_not_indexed(name: usize, value: &[u8], - sensitive: bool, dst: &mut BytesMut) - -> Result<(), EncoderError> -{ +fn encode_not_indexed( + name: usize, + value: &[u8], + sensitive: bool, + dst: &mut BytesMut, +) -> Result<(), EncoderError> { if sensitive { - try!(encode_int(name, 4, 0b10000, dst)); + encode_int(name, 4, 0b10000, dst)?; } else { - try!(encode_int(name, 4, 0, dst)); + encode_int(name, 4, 0, dst)?; } - try!(encode_str(value, dst)); + encode_str(value, dst)?; Ok(()) } -fn encode_not_indexed2(name: &[u8], value: &[u8], - sensitive: bool, dst: &mut BytesMut) - -> Result<(), EncoderError> -{ +fn encode_not_indexed2( + name: &[u8], + value: &[u8], + sensitive: bool, + dst: &mut BytesMut, +) -> Result<(), EncoderError> { if !dst.has_remaining_mut() { return Err(EncoderError::BufferOverflow); } @@ -298,8 +287,8 @@ fn encode_not_indexed2(name: &[u8], value: &[u8], dst.put_u8(0); } - try!(encode_str(name, dst)); - try!(encode_str(value, dst)); + encode_str(name, dst)?; + encode_str(value, dst)?; Ok(()) } @@ -317,7 +306,7 @@ fn encode_str(val: &[u8], dst: &mut BytesMut) -> Result<(), EncoderError> { dst.put_u8(0); // Encode with huffman - try!(huffman::encode(val, dst)); + huffman::encode(val, dst)?; let huff_len = dst.len() - (idx + 1); @@ -330,7 +319,7 @@ fn encode_str(val: &[u8], dst: &mut BytesMut) -> Result<(), EncoderError> { let head_len = { let mut head_dst = Cursor::new(&mut buf); - try!(encode_int(huff_len, 7, 0x80, &mut head_dst)); + encode_int(huff_len, 7, 0x80, &mut head_dst)?; head_dst.position() as usize }; @@ -343,8 +332,8 @@ fn encode_str(val: &[u8], dst: &mut BytesMut) -> Result<(), EncoderError> { // Shift the header forward for i in 0..huff_len { - let src_i = idx + 1 + (huff_len - (i+1)); - let dst_i = idx + head_len + (huff_len - (i+1)); + let src_i = idx + 1 + (huff_len - (i + 1)); + let dst_i = idx + head_len + (huff_len - (i + 1)); dst[dst_i] = dst[src_i]; } @@ -366,9 +355,8 @@ fn encode_int( mut value: usize, // The integer to encode prefix_bits: usize, // The number of bits in the prefix first_byte: u8, // The base upon which to start encoding the int - dst: &mut B) // The destination buffer - -> Result<(), EncoderError> -{ + dst: &mut B, +) -> Result<(), EncoderError> { let mut rem = dst.remaining_mut(); if rem == 0 { @@ -444,7 +432,7 @@ mod test { let res = encode(&mut encoder, vec![method("PATCH")]); assert_eq!(res[0], 0b01000000 | 2); // Incremental indexing w/ name pulled from table - assert_eq!(res[1], 0x80 | 5); // header value w/ huffman coding + assert_eq!(res[1], 0x80 | 5); // header value w/ huffman coding assert_eq!("PATCH", huff_decode(&res[2..7])); assert_eq!(encoder.table.len(), 1); @@ -522,7 +510,7 @@ mod test { for i in 1..65 { let key = format!("x-hello-world-{:02}", i); let res = encode(&mut encoder, vec![header(&key, &key)]); - assert_eq!(0x80 | (61 + (65-i)), res[0]); + assert_eq!(0x80 | (61 + (65 - i)), res[0]); } } @@ -547,7 +535,10 @@ mod test { let mut value = HeaderValue::from_bytes(b"12345").unwrap(); value.set_sensitive(true); - let header = Header::Field { name: Some(name), value: value }; + let header = Header::Field { + name: Some(name), + value: value, + }; // Now, try to encode the sensitive header @@ -564,7 +555,10 @@ mod test { let mut value = HeaderValue::from_bytes(b"12345").unwrap(); value.set_sensitive(true); - let header = Header::Field { name: Some(name), value: value }; + let header = Header::Field { + name: Some(name), + value: value, + }; let mut encoder = Encoder::default(); let res = encode(&mut encoder, vec![header]); @@ -576,13 +570,17 @@ mod test { // Using the name component of a previously indexed header (without // sensitive flag set) - let _ = encode(&mut encoder, vec![self::header("my-password", "not-so-secret")]); + let _ = encode(&mut encoder, + vec![self::header("my-password", "not-so-secret")]); let name = "my-password".parse().unwrap(); let mut value = HeaderValue::from_bytes(b"12345").unwrap(); value.set_sensitive(true); - let header = Header::Field { name: Some(name), value: value }; + let header = Header::Field { + name: Some(name), + value: value, + }; let res = encode(&mut encoder, vec![header]); assert_eq!(&[0b11111, 47], &res[..2]); @@ -743,16 +741,19 @@ mod test { fn test_nameless_header() { let mut encoder = Encoder::default(); - let res = encode(&mut encoder, vec![ - Header::Field { - name: Some("hello".parse().unwrap()), - value: HeaderValue::from_bytes(b"world").unwrap(), - }, - Header::Field { - name: None, - value: HeaderValue::from_bytes(b"zomg").unwrap(), - }, - ]); + let res = encode( + &mut encoder, + vec![ + Header::Field { + name: Some("hello".parse().unwrap()), + value: HeaderValue::from_bytes(b"world").unwrap(), + }, + Header::Field { + name: None, + value: HeaderValue::from_bytes(b"zomg").unwrap(), + }, + ], + ); assert_eq!(&[0x40, 0x80 | 4], &res[0..2]); assert_eq!("hello", huff_decode(&res[2..6])); @@ -824,7 +825,10 @@ mod test { let name = HeaderName::from_bytes(name.as_bytes()).unwrap(); let value = HeaderValue::from_bytes(val.as_bytes()).unwrap(); - Header::Field { name: Some(name), value: value } + Header::Field { + name: Some(name), + value: value, + } } fn huff_decode(src: &[u8]) -> BytesMut { diff --git a/src/hpack/header.rs b/src/hpack/header.rs index 8ab1244..9ec9beb 100644 --- a/src/hpack/header.rs +++ b/src/hpack/header.rs @@ -1,17 +1,14 @@ use super::DecoderError; +use bytes::Bytes; use http::{Method, StatusCode}; use http::header::{HeaderName, HeaderValue}; -use bytes::Bytes; use string::{String, TryFrom}; /// HTTP/2.0 Header #[derive(Debug, Clone, Eq, PartialEq)] pub enum Header { - Field { - name: T, - value: HeaderValue, - }, + Field { name: T, value: HeaderValue }, // TODO: Change these types to `http::uri` types. Authority(String), Method(Method), @@ -41,14 +38,25 @@ impl Header> { use self::Header::*; Ok(match self { - Field { name: Some(n), value } => Field { name: n, value: value }, - Field { name: None, value } => return Err(value), - Authority(v) => Authority(v), - Method(v) => Method(v), - Scheme(v) => Scheme(v), - Path(v) => Path(v), - Status(v) => Status(v), - }) + Field { + name: Some(n), + value, + } => { + Field { + name: n, + value: value, + } + } + Field { + name: None, + value, + } => return Err(value), + Authority(v) => Authority(v), + Method(v) => Method(v), + Scheme(v) => Scheme(v), + Path(v) => Path(v), + Status(v) => Status(v), + }) } } @@ -57,65 +65,59 @@ impl Header { if name[0] == b':' { match &name[1..] { b"authority" => { - let value = try!(String::try_from(value)); + let value = String::try_from(value)?; Ok(Header::Authority(value)) } b"method" => { - let method = try!(Method::from_bytes(&value)); + let method = Method::from_bytes(&value)?; Ok(Header::Method(method)) } b"scheme" => { - let value = try!(String::try_from(value)); + let value = String::try_from(value)?; Ok(Header::Scheme(value)) } b"path" => { - let value = try!(String::try_from(value)); + let value = String::try_from(value)?; Ok(Header::Path(value)) } b"status" => { - let status = try!(StatusCode::from_bytes(&value)); + let status = StatusCode::from_bytes(&value)?; Ok(Header::Status(status)) } - _ => { - Err(DecoderError::InvalidPseudoheader) - } + _ => Err(DecoderError::InvalidPseudoheader), } } else { // HTTP/2 requires lower case header names - let name = try!(HeaderName::from_lowercase(&name)); - let value = try!(HeaderValue::from_bytes(&value)); + let name = HeaderName::from_lowercase(&name)?; + let value = HeaderValue::from_bytes(&value)?; - Ok(Header::Field { name: name, value: value }) + Ok(Header::Field { + name: name, + value: value, + }) } } pub fn len(&self) -> usize { match *self { - Header::Field { ref name, ref value } => { - len(name, value) - } - Header::Authority(ref v) => { - 32 + 10 + v.len() - } - Header::Method(ref v) => { - 32 + 7 + v.as_ref().len() - } - Header::Scheme(ref v) => { - 32 + 7 + v.len() - } - Header::Path(ref v) => { - 32 + 5 + v.len() - } - Header::Status(_) => { - 32 + 7 + 3 - } + Header::Field { + ref name, + ref value, + } => len(name, value), + Header::Authority(ref v) => 32 + 10 + v.len(), + Header::Method(ref v) => 32 + 7 + v.as_ref().len(), + Header::Scheme(ref v) => 32 + 7 + v.len(), + Header::Path(ref v) => 32 + 5 + v.len(), + Header::Status(_) => 32 + 7 + 3, } } /// Returns the header name pub fn name(&self) -> Name { match *self { - Header::Field { ref name, .. } => Name::Field(name), + Header::Field { + ref name, .. + } => Name::Field(name), Header::Authority(..) => Name::Authority, Header::Method(..) => Name::Method, Header::Scheme(..) => Name::Scheme, @@ -126,7 +128,9 @@ impl Header { pub fn value_slice(&self) -> &[u8] { match *self { - Header::Field { ref value, .. } => value.as_ref(), + Header::Field { + ref value, .. + } => value.as_ref(), Header::Authority(ref v) => v.as_ref(), Header::Method(ref v) => v.as_ref().as_ref(), Header::Scheme(ref v) => v.as_ref(), @@ -137,10 +141,14 @@ impl Header { pub fn value_eq(&self, other: &Header) -> bool { match *self { - Header::Field { ref value, .. } => { + Header::Field { + ref value, .. + } => { let a = value; match *other { - Header::Field { ref value, .. } => a == value, + Header::Field { + ref value, .. + } => a == value, _ => false, } } @@ -179,7 +187,9 @@ impl Header { pub fn is_sensitive(&self) -> bool { match *self { - Header::Field { ref value, .. } => value.is_sensitive(), + Header::Field { + ref value, .. + } => value.is_sensitive(), // TODO: Technically these other header values can be sensitive too. _ => false, } @@ -189,17 +199,19 @@ impl Header { use http::header; match *self { - Header::Field { ref name, .. } => { + Header::Field { + ref name, .. + } => { match *name { header::AGE | - header::AUTHORIZATION | - header::CONTENT_LENGTH | - header::ETAG | - header::IF_MODIFIED_SINCE | - header::IF_NONE_MATCH | - header::LOCATION | - header::COOKIE | - header::SET_COOKIE => true, + header::AUTHORIZATION | + header::CONTENT_LENGTH | + header::ETAG | + header::IF_MODIFIED_SINCE | + header::IF_NONE_MATCH | + header::LOCATION | + header::COOKIE | + header::SET_COOKIE => true, _ => false, } } @@ -213,7 +225,15 @@ impl Header { impl From
for Header> { fn from(src: Header) -> Self { match src { - Header::Field { name, value } => Header::Field { name: Some(name), value }, + Header::Field { + name, + value, + } => { + Header::Field { + name: Some(name), + value, + } + } Header::Authority(v) => Header::Authority(v), Header::Method(v) => Header::Method(v), Header::Scheme(v) => Header::Scheme(v), @@ -228,22 +248,14 @@ impl<'a> Name<'a> { match self { Name::Field(name) => { Ok(Header::Field { - name: name.clone(), - value: try!(HeaderValue::from_bytes(&*value)), - }) - } - Name::Authority => { - Ok(Header::Authority(try!(String::try_from(value)))) - } - Name::Method => { - Ok(Header::Method(try!(Method::from_bytes(&*value)))) - } - Name::Scheme => { - Ok(Header::Scheme(try!(String::try_from(value)))) - } - Name::Path => { - Ok(Header::Path(try!(String::try_from(value)))) + name: name.clone(), + value: HeaderValue::from_bytes(&*value)?, + }) } + Name::Authority => Ok(Header::Authority(String::try_from(value)?)), + Name::Method => Ok(Header::Method(Method::from_bytes(&*value)?)), + Name::Scheme => Ok(Header::Scheme(String::try_from(value)?)), + Name::Path => Ok(Header::Path(String::try_from(value)?)), Name::Status => { match StatusCode::from_bytes(&value) { Ok(status) => Ok(Header::Status(status)), diff --git a/src/hpack/huffman/mod.rs b/src/hpack/huffman/mod.rs index 266e1d4..ce4d1ec 100644 --- a/src/hpack/huffman/mod.rs +++ b/src/hpack/huffman/mod.rs @@ -1,9 +1,9 @@ mod table; -use self::table::{ENCODE_TABLE, DECODE_TABLE}; +use self::table::{DECODE_TABLE, ENCODE_TABLE}; use hpack::{DecoderError, EncoderError}; -use bytes::{BytesMut, BufMut}; +use bytes::{BufMut, BytesMut}; // Constructed in the generated `table.rs` file struct Decoder { @@ -24,11 +24,11 @@ pub fn decode(src: &[u8], buf: &mut BytesMut) -> Result buf.reserve(src.len() << 1); for b in src { - if let Some(b) = try!(decoder.decode4(b >> 4)) { + if let Some(b) = decoder.decode4(b >> 4)? { buf.put_u8(b); } - if let Some(b) = try!(decoder.decode4(b & 0xf)) { + if let Some(b) = decoder.decode4(b & 0xf)? { buf.put_u8(b); } } @@ -161,10 +161,27 @@ mod test { #[test] fn encode_decode_str() { const DATA: &'static [&'static str] = &[ - "hello world", ":method", ":scheme", ":authority", "yahoo.co.jp", "GET", "http", ":path", "/images/top/sp2/cmn/logo-ns-130528.png", - "example.com", "hpack-test", "xxxxxxx1", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) Gecko/20100101 Firefox/16.0", - "accept", "Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "cookie", "B=76j09a189a6h4&b=3&s=0b", - "TE", "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi non bibendum libero. Etiam ultrices lorem ut", + "hello world", + ":method", + ":scheme", + ":authority", + "yahoo.co.jp", + "GET", + "http", + ":path", + "/images/top/sp2/cmn/logo-ns-130528.png", + "example.com", + "hpack-test", + "xxxxxxx1", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) Gecko/20100101 Firefox/16.0", + "accept", + "Accept", + "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", + "cookie", + "B=76j09a189a6h4&b=3&s=0b", + "TE", + "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi non bibendum libero. \ + Etiam ultrices lorem ut.", ]; for s in DATA { @@ -180,9 +197,8 @@ mod test { #[test] fn encode_decode_u8() { - const DATA: &'static [&'static [u8]] = &[ - b"\0", b"\0\0\0", b"\0\x01\x02\x03\x04\x05", b"\xFF\xF8", - ]; + const DATA: &'static [&'static [u8]] = + &[b"\0", b"\0\0\0", b"\0\x01\x02\x03\x04\x05", b"\xFF\xF8"]; for s in DATA { let mut dst = Vec::with_capacity(s.len()); diff --git a/src/hpack/mod.rs b/src/hpack/mod.rs index d86999c..4a0ab9e 100644 --- a/src/hpack/mod.rs +++ b/src/hpack/mod.rs @@ -7,6 +7,6 @@ mod table; #[cfg(test)] mod test; -pub use self::encoder::{Encoder, Encode, EncoderError, EncodeState}; -pub use self::header::Header; pub use self::decoder::{Decoder, DecoderError}; +pub use self::encoder::{Encode, EncodeState, Encoder, EncoderError}; +pub use self::header::Header; diff --git a/src/hpack/table.rs b/src/hpack/table.rs index fc94f4d..571d579 100644 --- a/src/hpack/table.rs +++ b/src/hpack/table.rs @@ -83,9 +83,7 @@ impl Table { max_size: max_size, } } else { - let capacity = cmp::max( - to_raw_capacity(capacity).next_power_of_two(), - 8); + let capacity = cmp::max(to_raw_capacity(capacity).next_power_of_two(), 8); Table { mask: capacity.wrapping_sub(1), @@ -203,12 +201,7 @@ impl Table { }); } - fn index_occupied(&mut self, - header: Header, - hash: HashValue, - mut index: usize) - -> Index - { + fn index_occupied(&mut self, header: Header, hash: HashValue, mut index: usize) -> Index { debug_assert!(self.assert_valid_state("top")); // There already is a match for the given header name. Check if a value @@ -256,14 +249,14 @@ impl Table { } } - fn index_vacant(&mut self, - header: Header, - hash: HashValue, - mut dist: usize, - mut probe: usize, - statik: Option<(usize, bool)>) - -> Index - { + fn index_vacant( + &mut self, + header: Header, + hash: HashValue, + mut dist: usize, + mut probe: usize, + statik: Option<(usize, bool)>, + ) -> Index { if header.is_sensitive() { return Index::new(statik, header); } @@ -299,10 +292,11 @@ impl Table { let pos_idx = 0usize.wrapping_sub(self.inserted); - let prev = mem::replace(&mut self.indices[probe], Some(Pos { - index: pos_idx, - hash: hash, - })); + let prev = mem::replace(&mut self.indices[probe], + Some(Pos { + index: pos_idx, + hash: hash, + })); if let Some(mut prev) = prev { // Shift forward @@ -331,10 +325,10 @@ impl Table { self.inserted = self.inserted.wrapping_add(1); self.slots.push_front(Slot { - hash: hash, - header: header, - next: None, - }); + hash: hash, + header: header, + next: None, + }); } pub fn resize(&mut self, size: usize) { @@ -383,11 +377,12 @@ impl Table { // Update the size self.size -= slot.header.len(); - debug_assert_eq!( - self.indices.iter().filter_map(|p| *p) - .filter(|p| p.index == pos_idx) - .count(), - 1); + debug_assert_eq!(self.indices + .iter() + .filter_map(|p| *p) + .filter(|p| p.index == pos_idx) + .count(), + 1); // Find the associated position probe_loop!(probe < self.indices.len(), { @@ -500,12 +495,12 @@ impl Table { } debug_assert!({ - let them = self.indices[probe].unwrap(); - let their_distance = probe_distance(self.mask, them.hash, probe); - let our_distance = probe_distance(self.mask, pos.hash, probe); + let them = self.indices[probe].unwrap(); + let their_distance = probe_distance(self.mask, them.hash, probe); + let our_distance = probe_distance(self.mask, pos.hash, probe); - their_distance >= our_distance - }); + their_distance >= our_distance + }); }); } } @@ -584,8 +579,10 @@ impl Table { } assert!(dist <= their_dist, - "could not find entry; actual={}; desired={}; probe={}, dist={}; their_dist={}; index={}; msg={}", - actual, desired, probe, dist, their_dist, index.wrapping_sub(self.inserted), msg); + "could not find entry; actual={}; desired={};" + + "probe={}, dist={}; their_dist={}; index={}; msg={}", + actual, desired, probe, dist, their_dist, + index.wrapping_sub(self.inserted), msg); dist += 1; }); @@ -661,7 +658,10 @@ fn hash_header(header: &Header) -> HashValue { /// boolean representing if the value matched as well. fn index_static(header: &Header) -> Option<(usize, bool)> { match *header { - Header::Field { ref name, ref value } => { + Header::Field { + ref name, + ref value, + } => { match *name { header::ACCEPT_CHARSET => Some((15, false)), header::ACCEPT_ENCODING => { diff --git a/src/hpack/test/fixture.rs b/src/hpack/test/fixture.rs index 86f4440..80f7144 100644 --- a/src/hpack/test/fixture.rs +++ b/src/hpack/test/fixture.rs @@ -2,15 +2,15 @@ extern crate bytes; extern crate hex; extern crate serde_json; -use hpack::{Header, Decoder, Encoder}; +use hpack::{Decoder, Encoder, Header}; use self::bytes::BytesMut; use self::hex::FromHex; use self::serde_json::Value; use std::fs::File; -use std::io::prelude::*; use std::io::Cursor; +use std::io::prelude::*; use std::path::Path; use std::str; @@ -27,7 +27,10 @@ fn test_story(story: Value) { let story = story.as_object().unwrap(); if let Some(cases) = story.get("cases") { - let mut cases: Vec<_> = cases.as_array().unwrap().iter() + let mut cases: Vec<_> = cases + .as_array() + .unwrap() + .iter() .map(|case| { let case = case.as_object().unwrap(); @@ -37,8 +40,11 @@ fn test_story(story: Value) { let wire = case.get("wire").unwrap().as_str().unwrap(); let wire: Vec = FromHex::from_hex(wire.as_bytes()).unwrap(); - let expect: Vec<_> = case.get("headers").unwrap() - .as_array().unwrap().iter() + let expect: Vec<_> = case.get("headers") + .unwrap() + .as_array() + .unwrap() + .iter() .map(|h| { let h = h.as_object().unwrap(); let (name, val) = h.iter().next().unwrap(); @@ -67,11 +73,13 @@ fn test_story(story: Value) { decoder.queue_size_update(size); } - decoder.decode(&mut Cursor::new(case.wire.clone().into()), |e| { - let (name, value) = expect.remove(0); - assert_eq!(name, key_str(&e)); - assert_eq!(value, value_str(&e)); - }).unwrap(); + decoder + .decode(&mut Cursor::new(case.wire.clone().into()), |e| { + let (name, value) = expect.remove(0); + assert_eq!(name, key_str(&e)); + assert_eq!(value, value_str(&e)); + }) + .unwrap(); assert_eq!(0, expect.len()); } @@ -88,15 +96,22 @@ fn test_story(story: Value) { decoder.queue_size_update(size); } - let mut input: Vec<_> = case.expect.iter().map(|&(ref name, ref value)| { - Header::new(name.clone().into(), value.clone().into()).unwrap().into() - }).collect(); + let mut input: Vec<_> = case.expect + .iter() + .map(|&(ref name, ref value)| { + Header::new(name.clone().into(), value.clone().into()) + .unwrap() + .into() + }) + .collect(); encoder.encode(None, &mut input.clone().into_iter(), &mut buf); - decoder.decode(&mut Cursor::new(buf.into()), |e| { - assert_eq!(e, input.remove(0).reify().unwrap()); - }).unwrap(); + decoder + .decode(&mut Cursor::new(buf.into()), |e| { + assert_eq!(e, input.remove(0).reify().unwrap()); + }) + .unwrap(); assert_eq!(0, input.len()); } @@ -112,7 +127,9 @@ struct Case { fn key_str(e: &Header) -> &str { match *e { - Header::Field { ref name, .. } => name.as_str(), + Header::Field { + ref name, .. + } => name.as_str(), Header::Authority(..) => ":authority", Header::Method(..) => ":method", Header::Scheme(..) => ":scheme", @@ -123,7 +140,9 @@ fn key_str(e: &Header) -> &str { fn value_str(e: &Header) -> &str { match *e { - Header::Field { ref value, .. } => value.to_str().unwrap(), + Header::Field { + ref value, .. + } => value.to_str().unwrap(), Header::Authority(ref v) => &**v, Header::Method(ref m) => m.as_str(), Header::Scheme(ref v) => &**v, diff --git a/src/hpack/test/fuzz.rs b/src/hpack/test/fuzz.rs index 79b37f4..884e9b7 100644 --- a/src/hpack/test/fuzz.rs +++ b/src/hpack/test/fuzz.rs @@ -2,13 +2,13 @@ extern crate bytes; extern crate quickcheck; extern crate rand; -use hpack::{Header, Decoder, Encoder, Encode}; +use hpack::{Decoder, Encode, Encoder, Header}; use http::header::{HeaderName, HeaderValue}; -use self::bytes::{BytesMut, Bytes}; -use self::quickcheck::{QuickCheck, Arbitrary, Gen, TestResult}; -use self::rand::{StdRng, Rng, SeedableRng}; +use self::bytes::{Bytes, BytesMut}; +use self::quickcheck::{Arbitrary, Gen, QuickCheck, TestResult}; +use self::rand::{Rng, SeedableRng, StdRng}; use std::io::Cursor; @@ -130,8 +130,7 @@ impl FuzzHpack { let mut index = None; let mut input = frame.headers.into_iter(); - let mut buf = BytesMut::with_capacity( - chunks.pop().unwrap_or(MAX_CHUNK)); + let mut buf = BytesMut::with_capacity(chunks.pop().unwrap_or(MAX_CHUNK)); if let Some(max) = frame.resizes.iter().max() { decoder.queue_size_update(*max); @@ -149,20 +148,23 @@ impl FuzzHpack { index = Some(i); // Decode the chunk! - decoder.decode(&mut Cursor::new(buf.into()), |e| { - assert_eq!(e, expect.remove(0).reify().unwrap()); - }).unwrap(); + decoder + .decode(&mut Cursor::new(buf.into()), |e| { + assert_eq!(e, expect.remove(0).reify().unwrap()); + }) + .unwrap(); - buf = BytesMut::with_capacity( - chunks.pop().unwrap_or(MAX_CHUNK)); + buf = BytesMut::with_capacity(chunks.pop().unwrap_or(MAX_CHUNK)); } } } // Decode the chunk! - decoder.decode(&mut Cursor::new(buf.into()), |e| { - assert_eq!(e, expect.remove(0).reify().unwrap()); - }).unwrap(); + decoder + .decode(&mut Cursor::new(buf.into()), |e| { + assert_eq!(e, expect.remove(0).reify().unwrap()); + }) + .unwrap(); } assert_eq!(0, expect.len()); @@ -193,9 +195,9 @@ fn gen_header(g: &mut StdRng) -> Header> { 4 => Method::DELETE, 5 => { let n: usize = g.gen_range(3, 7); - let bytes: Vec = (0..n).map(|_| { - g.choose(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ").unwrap().clone() - }).collect(); + let bytes: Vec = (0..n) + .map(|_| g.choose(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ").unwrap().clone()) + .collect(); Method::from_bytes(&bytes).unwrap() } @@ -237,7 +239,10 @@ fn gen_header(g: &mut StdRng) -> Header> { value.set_sensitive(true); } - Header::Field { name: Some(name), value: value } + Header::Field { + name: Some(name), + value: value, + } } } @@ -320,7 +325,8 @@ fn gen_header_name(g: &mut StdRng) -> HeaderName { header::X_DNS_PREFETCH_CONTROL, header::X_FRAME_OPTIONS, header::X_XSS_PROTECTION, - ]).unwrap().clone() + ]).unwrap() + .clone() } else { let value = gen_string(g, 1, 25); HeaderName::from_bytes(value.as_bytes()).unwrap() @@ -333,10 +339,14 @@ fn gen_header_value(g: &mut StdRng) -> HeaderValue { } fn gen_string(g: &mut StdRng, min: usize, max: usize) -> String { - let bytes: Vec<_> = (min..max).map(|_| { - // Chars to pick from - g.choose(b"ABCDEFGHIJKLMNOPQRSTUVabcdefghilpqrstuvwxyz----").unwrap().clone() - }).collect(); + let bytes: Vec<_> = (min..max) + .map(|_| { + // Chars to pick from + g.choose(b"ABCDEFGHIJKLMNOPQRSTUVabcdefghilpqrstuvwxyz----") + .unwrap() + .clone() + }) + .collect(); String::from_utf8(bytes).unwrap() } diff --git a/src/lib.rs b/src/lib.rs index e8e6e91..08eee52 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,12 +7,15 @@ extern crate futures; extern crate tokio_io; // HTTP types + extern crate http; // Buffer utilities + extern crate bytes; // Hash function used for HPACK encoding and tracking stream states. + extern crate fnv; extern crate byteorder; @@ -43,4 +46,4 @@ pub mod server; pub use error::{Error, Reason}; #[cfg(feature = "unstable")] -pub use codec::{Codec, SendError, RecvError, UserError}; +pub use codec::{Codec, RecvError, SendError, UserError}; diff --git a/src/proto/connection.rs b/src/proto/connection.rs index 0334b70..e17030d 100644 --- a/src/proto/connection.rs +++ b/src/proto/connection.rs @@ -1,13 +1,13 @@ -use {client, frame, server, proto}; +use {client, frame, proto, server}; +use codec::{RecvError, SendError}; use frame::Reason; -use codec::{SendError, RecvError}; use frame::DEFAULT_INITIAL_WINDOW_SIZE; use proto::*; -use http::Request; -use futures::{Stream}; use bytes::{Bytes, IntoBuf}; +use futures::Stream; +use http::Request; use tokio_io::{AsyncRead, AsyncWrite}; use std::marker::PhantomData; @@ -15,7 +15,8 @@ use std::marker::PhantomData; /// An H2 connection #[derive(Debug)] pub(crate) struct Connection - where P: Peer, +where + P: Peer, { /// Tracks the connection level state transitions. state: State, @@ -52,18 +53,19 @@ enum State { } impl Connection - where T: AsyncRead + AsyncWrite, - P: Peer, - B: IntoBuf, +where + T: AsyncRead + AsyncWrite, + P: Peer, + B: IntoBuf, { pub fn new(codec: Codec>) -> Connection { // TODO: Actually configure let streams = Streams::new(streams::Config { - max_remote_initiated: None, - init_remote_window_sz: DEFAULT_INITIAL_WINDOW_SIZE, - max_local_initiated: None, - init_local_window_sz: DEFAULT_INITIAL_WINDOW_SIZE, - }); + max_remote_initiated: None, + init_remote_window_sz: DEFAULT_INITIAL_WINDOW_SIZE, + max_local_initiated: None, + init_local_window_sz: DEFAULT_INITIAL_WINDOW_SIZE, + }); Connection { state: State::Open, @@ -83,7 +85,8 @@ impl Connection // The order of these calls don't really matter too much as only one // should have pending work. try_ready!(self.ping_pong.send_pending_pong(&mut self.codec)); - try_ready!(self.settings.send_pending_ack(&mut self.codec, &mut self.streams)); + try_ready!(self.settings + .send_pending_ack(&mut self.codec, &mut self.streams)); try_ready!(self.streams.send_pending_refusal(&mut self.codec)); Ok(().into()) @@ -128,7 +131,10 @@ impl Connection // Attempting to read a frame resulted in a stream level error. // This is handled by resetting the frame then trying to read // another frame. - Err(Stream { id, reason }) => { + Err(Stream { + id, + reason, + }) => { trace!("stream level error; id={:?}; reason={:?}", id, reason); self.streams.send_reset(id, reason); } @@ -146,14 +152,16 @@ impl Connection return Err(e); } } - }, + } State::GoAway(frame) => { // Ensure the codec is ready to accept the frame try_ready!(self.codec.poll_ready()); // Buffer the GO_AWAY frame - self.codec.buffer(frame.into()) - .ok().expect("invalid GO_AWAY frame"); + self.codec + .buffer(frame.into()) + .ok() + .expect("invalid GO_AWAY frame"); // GO_AWAY sent, transition the connection to an errored state self.state = State::Flush(frame.reason()); @@ -182,15 +190,15 @@ impl Connection match try_ready!(self.codec.poll()) { Some(Headers(frame)) => { trace!("recv HEADERS; frame={:?}", frame); - try!(self.streams.recv_headers(frame)); + self.streams.recv_headers(frame)?; } Some(Data(frame)) => { trace!("recv DATA; frame={:?}", frame); - try!(self.streams.recv_data(frame)); + self.streams.recv_data(frame)?; } Some(Reset(frame)) => { trace!("recv RST_STREAM; frame={:?}", frame); - try!(self.streams.recv_reset(frame)); + self.streams.recv_reset(frame)?; } Some(PushPromise(frame)) => { trace!("recv PUSH_PROMISE; frame={:?}", frame); @@ -229,8 +237,9 @@ impl Connection } impl Connection - where T: AsyncRead + AsyncWrite, - B: IntoBuf, +where + T: AsyncRead + AsyncWrite, + B: IntoBuf, { /// Returns `Ready` when new the connection is able to support a new request stream. pub fn poll_send_request_ready(&mut self) -> Async<()> { @@ -238,16 +247,19 @@ impl Connection } /// Initialize a new HTTP/2.0 stream and send the message. - pub fn send_request(&mut self, request: Request<()>, end_of_stream: bool) - -> Result, SendError> - { + pub fn send_request( + &mut self, + request: Request<()>, + end_of_stream: bool, + ) -> Result, SendError> { self.streams.send_request(request, end_of_stream) } } impl Connection - where T: AsyncRead + AsyncWrite, - B: IntoBuf, +where + T: AsyncRead + AsyncWrite, + B: IntoBuf, { pub fn next_incoming(&mut self) -> Option> { self.streams.next_incoming() @@ -256,9 +268,10 @@ impl Connection #[cfg(feature = "unstable")] impl Connection - where T: AsyncRead + AsyncWrite, - P: Peer, - B: IntoBuf, +where + T: AsyncRead + AsyncWrite, + P: Peer, + B: IntoBuf, { pub fn num_active_streams(&self) -> usize { self.streams.num_active_streams() diff --git a/src/proto/error.rs b/src/proto/error.rs index 7615874..f26fbcb 100644 --- a/src/proto/error.rs +++ b/src/proto/error.rs @@ -1,5 +1,5 @@ -use frame::Reason; use codec::RecvError; +use frame::Reason; use std::io; diff --git a/src/proto/mod.rs b/src/proto/mod.rs index 54036b5..a6cbf53 100644 --- a/src/proto/mod.rs +++ b/src/proto/mod.rs @@ -8,7 +8,7 @@ mod streams; pub(crate) use self::connection::Connection; pub(crate) use self::error::Error; pub(crate) use self::peer::Peer; -pub(crate) use self::streams::{Streams, StreamRef}; +pub(crate) use self::streams::{StreamRef, Streams}; use codec::Codec; @@ -18,7 +18,7 @@ use self::streams::Prioritized; use frame::{self, Frame}; -use futures::{task, Poll, Async}; +use futures::{task, Async, Poll}; use futures::task::Task; use bytes::Buf; diff --git a/src/proto/peer.rs b/src/proto/peer.rs index 2925bd3..ff5073c 100644 --- a/src/proto/peer.rs +++ b/src/proto/peer.rs @@ -1,5 +1,5 @@ -use frame::{Headers, StreamId}; use codec::RecvError; +use frame::{Headers, StreamId}; use std::fmt; @@ -13,10 +13,7 @@ pub trait Peer { fn is_server() -> bool; - fn convert_send_message( - id: StreamId, - headers: Self::Send, - end_of_stream: bool) -> Headers; + fn convert_send_message(id: StreamId, headers: Self::Send, end_of_stream: bool) -> Headers; fn convert_poll_message(headers: Headers) -> Result; diff --git a/src/proto/ping_pong.rs b/src/proto/ping_pong.rs index 1a6f096..c49f047 100644 --- a/src/proto/ping_pong.rs +++ b/src/proto/ping_pong.rs @@ -14,7 +14,8 @@ pub struct PingPong { } impl PingPong - where B: Buf, +where + B: Buf, { pub fn new() -> Self { PingPong { @@ -46,7 +47,8 @@ impl PingPong /// Send any pending pongs. pub fn send_pending_pong(&mut self, dst: &mut Codec) -> Poll<(), io::Error> - where T: AsyncWrite, + where + T: AsyncWrite, { if let Some(pong) = self.sending_pong.take() { if !dst.poll_ready()?.is_ready() { diff --git a/src/proto/settings.rs b/src/proto/settings.rs index 2361e9f..df6cbd0 100644 --- a/src/proto/settings.rs +++ b/src/proto/settings.rs @@ -1,5 +1,5 @@ -use frame; use codec::RecvError; +use frame; use proto::*; #[derive(Debug)] @@ -20,21 +20,23 @@ impl Settings { pub fn recv_settings(&mut self, frame: frame::Settings) { if frame.is_ack() { debug!("received remote settings ack"); - // TODO: handle acks + // TODO: handle acks } else { assert!(self.pending.is_none()); self.pending = Some(frame); } } - pub fn send_pending_ack(&mut self, - dst: &mut Codec, - streams: &mut Streams) - -> Poll<(), RecvError> - where T: AsyncWrite, - B: Buf, - C: Buf, - P: Peer, + pub fn send_pending_ack( + &mut self, + dst: &mut Codec, + streams: &mut Streams, + ) -> Poll<(), RecvError> + where + T: AsyncWrite, + B: Buf, + C: Buf, + P: Peer, { trace!("send_pending_ack; pending={:?}", self.pending); @@ -48,7 +50,9 @@ impl Settings { let frame = frame::Settings::ack(); // Buffer the settings frame - dst.buffer(frame.into()).ok().expect("invalid settings frame"); + dst.buffer(frame.into()) + .ok() + .expect("invalid settings frame"); trace!("ACK sent; applying settings"); diff --git a/src/proto/streams/buffer.rs b/src/proto/streams/buffer.rs index 6ae33f4..6feb070 100644 --- a/src/proto/streams/buffer.rs +++ b/src/proto/streams/buffer.rs @@ -50,9 +50,9 @@ impl Deque { pub fn push_back(&mut self, buf: &mut Buffer, value: T) { let key = buf.slab.insert(Slot { - value, - next: None, - }); + value, + next: None, + }); match self.indices { Some(ref mut idxs) => { @@ -61,18 +61,18 @@ impl Deque { } None => { self.indices = Some(Indices { - head: key, - tail: key, - }); + head: key, + tail: key, + }); } } } pub fn push_front(&mut self, buf: &mut Buffer, value: T) { let key = buf.slab.insert(Slot { - value, - next: None, - }); + value, + next: None, + }); match self.indices { Some(ref mut idxs) => { @@ -81,9 +81,9 @@ impl Deque { } None => { self.indices = Some(Indices { - head: key, - tail: key, - }); + head: key, + tail: key, + }); } } } @@ -109,9 +109,7 @@ impl Deque { pub fn peek_front<'a>(&self, buf: &'a Buffer) -> Option<&'a T> { match self.indices { - Some(idxs) => { - Some(&buf.slab[idxs.head].value) - } + Some(idxs) => Some(&buf.slab[idxs.head].value), None => None, } } diff --git a/src/proto/streams/counts.rs b/src/proto/streams/counts.rs index 7e69969..ffd1e3c 100644 --- a/src/proto/streams/counts.rs +++ b/src/proto/streams/counts.rs @@ -1,12 +1,13 @@ -use client; use super::*; +use client; -use std::usize; use std::marker::PhantomData; +use std::usize; #[derive(Debug)] pub(super) struct Counts

- where P: Peer, +where + P: Peer, { /// Maximum number of locally initiated streams max_send_streams: Option, @@ -27,7 +28,8 @@ pub(super) struct Counts

} impl

Counts

- where P: Peer, +where + P: Peer, { /// Create a new `Counts` using the provided configuration values. pub fn new(config: &Config) -> Self { @@ -94,7 +96,8 @@ impl

Counts

/// If the stream state transitions to closed, this function will perform /// all necessary cleanup. pub fn transition(&mut self, mut stream: store::Ptr, f: F) -> U - where F: FnOnce(&mut Self, &mut store::Ptr) -> U + where + F: FnOnce(&mut Self, &mut store::Ptr) -> U, { let is_counted = stream.state.is_counted(); diff --git a/src/proto/streams/flow_control.rs b/src/proto/streams/flow_control.rs index a9b2999..08f3900 100644 --- a/src/proto/streams/flow_control.rs +++ b/src/proto/streams/flow_control.rs @@ -1,5 +1,5 @@ use frame::Reason; -use proto::{MAX_WINDOW_SIZE, WindowSize}; +use proto::{WindowSize, MAX_WINDOW_SIZE}; // We don't want to send WINDOW_UPDATE frames for tiny changes, but instead // aggregate them when the changes are significant. Many implementations do @@ -87,8 +87,7 @@ impl FlowControl { } let unclaimed = available - self.window_size; - let threshold = self.window_size / UNCLAIMED_DENOMINATOR - * UNCLAIMED_NUMERATOR; + let threshold = self.window_size / UNCLAIMED_DENOMINATOR * UNCLAIMED_NUMERATOR; if unclaimed < threshold { None @@ -111,7 +110,10 @@ impl FlowControl { return Err(Reason::FlowControlError); } - trace!("inc_window; sz={}; old={}; new={}", sz, self.window_size, val); + trace!("inc_window; sz={}; old={}; new={}", + sz, + self.window_size, + val); self.window_size = val; Ok(()) @@ -130,7 +132,9 @@ impl FlowControl { /// must ensure that the window has capacity. pub fn send_data(&mut self, sz: WindowSize) { trace!("send_data; sz={}; window={}; available={}", - sz, self.window_size, self.available); + sz, + self.window_size, + self.available); // Ensure that the argument is correct assert!(sz <= self.window_size as WindowSize); diff --git a/src/proto/streams/mod.rs b/src/proto/streams/mod.rs index 681a85f..9783b23 100644 --- a/src/proto/streams/mod.rs +++ b/src/proto/streams/mod.rs @@ -9,8 +9,8 @@ mod store; mod stream; mod streams; -pub(crate) use self::streams::{Streams, StreamRef}; pub(crate) use self::prioritize::Prioritized; +pub(crate) use self::streams::{StreamRef, Streams}; use self::buffer::Buffer; use self::counts::Counts; @@ -19,15 +19,15 @@ use self::prioritize::Prioritize; use self::recv::Recv; use self::send::Send; use self::state::State; -use self::store::{Store, Entry}; +use self::store::{Entry, Store}; use self::stream::Stream; +use error::Reason::*; use frame::StreamId; use proto::*; -use error::Reason::*; -use http::{Request, Response}; use bytes::Bytes; +use http::{Request, Response}; #[derive(Debug)] pub struct Config { diff --git a/src/proto/streams/prioritize.rs b/src/proto/streams/prioritize.rs index a8801c6..2cb1a3a 100644 --- a/src/proto/streams/prioritize.rs +++ b/src/proto/streams/prioritize.rs @@ -8,12 +8,13 @@ use codec::UserError::*; use bytes::buf::Take; +use std::{cmp, fmt}; use std::io; -use std::{fmt, cmp}; #[derive(Debug)] pub(super) struct Prioritize - where P: Peer, +where + P: Peer, { /// Queue of streams waiting for socket capacity to send a frame pending_send: store::Queue, @@ -41,14 +42,16 @@ pub(crate) struct Prioritized { // ===== impl Prioritize ===== impl Prioritize - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { pub fn new(config: &Config) -> Prioritize { let mut flow = FlowControl::new(); flow.inc_window(config.init_local_window_sz) - .ok().expect("invalid initial window size"); + .ok() + .expect("invalid initial window size"); flow.assign_capacity(config.init_local_window_sz); @@ -63,11 +66,12 @@ impl Prioritize } /// Queue a frame to be sent to the remote - pub fn queue_frame(&mut self, - frame: Frame, - stream: &mut store::Ptr, - task: &mut Option) - { + pub fn queue_frame( + &mut self, + frame: Frame, + stream: &mut store::Ptr, + task: &mut Option, + ) { // Queue the frame in the buffer stream.pending_send.push_back(&mut self.buffer, frame); @@ -81,12 +85,12 @@ impl Prioritize } /// Send a data frame - pub fn send_data(&mut self, - frame: frame::Data, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), UserError> - { + pub fn send_data( + &mut self, + frame: frame::Data, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), UserError> { let sz = frame.payload().remaining(); if sz > MAX_WINDOW_SIZE as usize { @@ -108,7 +112,9 @@ impl Prioritize stream.buffered_send_data += sz; trace!("send_data; sz={}; buffered={}; requested={}", - sz, stream.buffered_send_data, stream.requested_send_capacity); + sz, + stream.buffered_send_data, + stream.requested_send_capacity); // Implicitly request more send capacity if not enough has been // requested yet. @@ -136,7 +142,9 @@ impl Prioritize // The stream has no capacity to send the frame now, save it but // don't notify the conneciton task. Once additional capacity // becomes available, the frame will be flushed. - stream.pending_send.push_back(&mut self.buffer, frame.into()); + stream + .pending_send + .push_back(&mut self.buffer, frame.into()); } Ok(()) @@ -183,13 +191,16 @@ impl Prioritize } } - pub fn recv_stream_window_update(&mut self, - inc: WindowSize, - stream: &mut store::Ptr) - -> Result<(), Reason> - { + pub fn recv_stream_window_update( + &mut self, + inc: WindowSize, + stream: &mut store::Ptr, + ) -> Result<(), Reason> { trace!("recv_stream_window_update; stream={:?}; state={:?}; inc={}; flow={:?}", - stream.id, stream.state, inc, stream.send_flow); + stream.id, + stream.state, + inc, + stream.send_flow); // Update the stream level flow control. stream.send_flow.inc_window(inc)?; @@ -201,11 +212,11 @@ impl Prioritize Ok(()) } - pub fn recv_connection_window_update(&mut self, - inc: WindowSize, - store: &mut Store) - -> Result<(), Reason> - { + pub fn recv_connection_window_update( + &mut self, + inc: WindowSize, + store: &mut Store, + ) -> Result<(), Reason> { // Update the connection's window self.flow.inc_window(inc)?; @@ -213,10 +224,9 @@ impl Prioritize Ok(()) } - pub fn assign_connection_capacity(&mut self, - inc: WindowSize, - store: &mut R) - where R: Resolve + pub fn assign_connection_capacity(&mut self, inc: WindowSize, store: &mut R) + where + R: Resolve, { self.flow.assign_capacity(inc); @@ -244,10 +254,9 @@ impl Prioritize // The amount of additional capacity that the stream requests. // Don't assign more than the window has available! - let additional = cmp::min( - total_requested - stream.send_flow.available(), - // Can't assign more than what is available - stream.send_flow.window_size() - stream.send_flow.available()); + let additional = cmp::min(total_requested - stream.send_flow.available(), + // Can't assign more than what is available + stream.send_flow.window_size() - stream.send_flow.available()); trace!("try_assign_capacity; requested={}; additional={}; buffered={}; window={}; conn={}", total_requested, @@ -265,7 +274,8 @@ impl Prioritize // streaming state (more data could be sent) or there is buffered data // waiting to be sent. debug_assert!(stream.state.is_send_streaming() || stream.buffered_send_data > 0, - "state={:?}", stream.state); + "state={:?}", + stream.state); // The amount of currently available capacity on the connection let conn_available = self.flow.available(); @@ -286,7 +296,8 @@ impl Prioritize self.flow.claim_capacity(assign); } - trace!("try_assign_capacity; available={}; requested={}; buffered={}; has_unavailable={:?}", + trace!("try_assign_capacity; available={}; requested={}; buffered={}; \ + has_unavailable={:?}", stream.send_flow.available(), stream.requested_send_capacity, stream.buffered_send_data, @@ -324,12 +335,14 @@ impl Prioritize } } - pub fn poll_complete(&mut self, - store: &mut Store, - counts: &mut Counts

, - dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn poll_complete( + &mut self, + store: &mut Store, + counts: &mut Counts

, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { // Ensure codec is ready try_ready!(dst.poll_ready()); @@ -378,15 +391,18 @@ impl Prioritize /// When a data frame is written to the codec, it may not be written in its /// entirety (large chunks are split up into potentially many data frames). /// In this case, the stream needs to be reprioritized. - fn reclaim_frame(&mut self, - store: &mut Store, - dst: &mut Codec>) -> bool - { + fn reclaim_frame( + &mut self, + store: &mut Store, + dst: &mut Codec>, + ) -> bool { trace!("try reclaim frame"); // First check if there are any data chunks to take back if let Some(frame) = dst.take_last_data_frame() { - trace!(" -> reclaimed; frame={:?}; sz={}", frame, frame.payload().remaining()); + trace!(" -> reclaimed; frame={:?}; sz={}", + frame, + frame.payload().remaining()); let mut eos = false; let key = frame.payload().stream; @@ -435,9 +451,12 @@ impl Prioritize } } - fn pop_frame(&mut self, store: &mut Store, max_len: usize, counts: &mut Counts

) - -> Option>> - { + fn pop_frame( + &mut self, + store: &mut Store, + max_len: usize, + counts: &mut Counts

, + ) -> Option>> { trace!("pop_frame"); loop { @@ -455,7 +474,8 @@ impl Prioritize let stream_capacity = stream.send_flow.available(); let sz = frame.payload().remaining(); - trace!(" --> data frame; stream={:?}; sz={}; eos={:?}; window={}; available={}; requested={}", + trace!(" --> data frame; stream={:?}; sz={}; eos={:?}; \ + window={}; available={}; requested={}", frame.stream_id(), sz, frame.is_end_stream(), @@ -479,7 +499,9 @@ impl Prioritize // happen if the remote reduced the stream // window. In this case, we need to buffer the // frame and wait for a window update... - stream.pending_send.push_front(&mut self.buffer, frame.into()); + stream + .pending_send + .push_front(&mut self.buffer, frame.into()); continue; } @@ -556,7 +578,8 @@ impl Prioritize // ===== impl Prioritized ===== impl Buf for Prioritized - where B: Buf, +where + B: Buf, { fn remaining(&self) -> usize { self.inner.remaining() diff --git a/src/proto/streams/recv.rs b/src/proto/streams/recv.rs index 551845a..c6a891e 100644 --- a/src/proto/streams/recv.rs +++ b/src/proto/streams/recv.rs @@ -1,8 +1,8 @@ -use {client, server, frame, proto}; -use frame::Reason; -use codec::{RecvError, UserError}; -use proto::*; use super::*; +use {client, frame, proto, server}; +use codec::{RecvError, UserError}; +use frame::Reason; +use proto::*; use http::HeaderMap; @@ -11,7 +11,8 @@ use std::marker::PhantomData; #[derive(Debug)] pub(super) struct Recv - where P: Peer, +where + P: Peer, { /// Initial window size of remote initiated streams init_window_sz: WindowSize, @@ -54,20 +55,18 @@ struct Indices { } impl Recv - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { pub fn new(config: &Config) -> Self { - let next_stream_id = if P::is_server() { - 1 - } else { - 2 - }; + let next_stream_id = if P::is_server() { 1 } else { 2 }; let mut flow = FlowControl::new(); flow.inc_window(config.init_remote_window_sz) - .ok().expect("invalid initial remote window size"); + .ok() + .expect("invalid initial remote window size"); flow.assign_capacity(config.init_remote_window_sz); Recv { @@ -96,12 +95,14 @@ impl Recv /// Update state reflecting a new, remotely opened stream /// /// Returns the stream state if successful. `None` if refused - pub fn open(&mut self, id: StreamId, counts: &mut Counts

) - -> Result, RecvError> - { + pub fn open( + &mut self, + id: StreamId, + counts: &mut Counts

, + ) -> Result, RecvError> { assert!(self.refused.is_none()); - try!(self.ensure_can_open(id)); + self.ensure_can_open(id)?; if id < self.next_stream_id { return Err(RecvError::Connection(ProtocolError)); @@ -121,12 +122,12 @@ impl Recv /// Transition the stream state based on receiving headers /// /// The caller ensures that the frame represents headers and not trailers. - pub fn recv_headers(&mut self, - frame: frame::Headers, - stream: &mut store::Ptr, - counts: &mut Counts

) - -> Result<(), RecvError> - { + pub fn recv_headers( + &mut self, + frame: frame::Headers, + stream: &mut store::Ptr, + counts: &mut Counts

, + ) -> Result<(), RecvError> { trace!("opening stream; init_window={}", self.init_window_sz); let is_initial = stream.state.recv_open(frame.is_end_stream())?; @@ -159,7 +160,9 @@ impl Recv let message = P::convert_poll_message(frame)?; // Push the frame onto the stream's recv buffer - stream.pending_recv.push_back(&mut self.buffer, Event::Headers(message)); + stream + .pending_recv + .push_back(&mut self.buffer, Event::Headers(message)); stream.notify_recv(); // Only servers can receive a headers frame that initiates the stream. @@ -172,37 +175,39 @@ impl Recv } /// Transition the stream based on receiving trailers - pub fn recv_trailers(&mut self, - frame: frame::Headers, - stream: &mut store::Ptr) - -> Result<(), RecvError> - { + pub fn recv_trailers( + &mut self, + frame: frame::Headers, + stream: &mut store::Ptr, + ) -> Result<(), RecvError> { // Transition the state stream.state.recv_close()?; if stream.ensure_content_length_zero().is_err() { return Err(RecvError::Stream { - id: stream.id, - reason: ProtocolError, - }); + id: stream.id, + reason: ProtocolError, + }); } let trailers = frame.into_fields(); // Push the frame onto the stream's recv buffer - stream.pending_recv.push_back(&mut self.buffer, Event::Trailers(trailers)); + stream + .pending_recv + .push_back(&mut self.buffer, Event::Trailers(trailers)); stream.notify_recv(); Ok(()) } /// Releases capacity back to the connection - pub fn release_capacity(&mut self, - capacity: WindowSize, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), UserError> - { + pub fn release_capacity( + &mut self, + capacity: WindowSize, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), UserError> { trace!("release_capacity; size={}", capacity); if capacity > stream.in_flight_recv_data { @@ -233,16 +238,18 @@ impl Recv return false; } - stream.pending_recv.peek_front(&self.buffer) + stream + .pending_recv + .peek_front(&self.buffer) .map(|event| !event.is_data()) .unwrap_or(true) } - pub fn recv_data(&mut self, - frame: frame::Data, - stream: &mut store::Ptr) - -> Result<(), RecvError> - { + pub fn recv_data( + &mut self, + frame: frame::Data, + stream: &mut store::Ptr, + ) -> Result<(), RecvError> { let sz = frame.payload().len(); if sz > MAX_WINDOW_SIZE as usize { @@ -258,7 +265,9 @@ impl Recv } trace!("recv_data; size={}; connection={}; stream={}", - sz, self.flow.window_size(), stream.recv_flow.window_size()); + sz, + self.flow.window_size(), + stream.recv_flow.window_size()); // Ensure that there is enough capacity on the connection before acting // on the stream. @@ -277,17 +286,17 @@ impl Recv if stream.dec_content_length(frame.payload().len()).is_err() { return Err(RecvError::Stream { - id: stream.id, - reason: ProtocolError, - }); + id: stream.id, + reason: ProtocolError, + }); } if frame.is_end_stream() { if stream.ensure_content_length_zero().is_err() { return Err(RecvError::Stream { - id: stream.id, - reason: ProtocolError, - }); + id: stream.id, + reason: ProtocolError, + }); } if stream.state.recv_close().is_err() { @@ -304,18 +313,20 @@ impl Recv Ok(()) } - pub fn recv_push_promise(&mut self, - frame: frame::PushPromise, - send: &Send, - stream: store::Key, - store: &mut Store) - -> Result<(), RecvError> - { + pub fn recv_push_promise( + &mut self, + frame: frame::PushPromise, + send: &Send, + stream: store::Key, + store: &mut Store, + ) -> Result<(), RecvError> { // First, make sure that the values are legit self.ensure_can_reserve(frame.promised_id())?; // Make sure that the stream state is valid - store[stream].state.ensure_recv_open() + store[stream] + .state + .ensure_recv_open() .map_err(|e| e.into_connection_recv_error())?; // TODO: Streams in the reserved states do not count towards the concurrency @@ -332,10 +343,9 @@ impl Recv // TODO: All earlier stream IDs should be implicitly closed. // Now, create a new entry for the stream - let mut new_stream = Stream::new( - frame.promised_id(), - send.init_window_sz(), - self.init_window_sz); + let mut new_stream = Stream::new(frame.promised_id(), + send.init_window_sz(), + self.init_window_sz); new_stream.state.reserve_remote()?; @@ -343,8 +353,7 @@ impl Recv { // Store the stream - let mut new_stream = store - .insert(frame.promised_id(), new_stream); + let mut new_stream = store.insert(frame.promised_id(), new_stream); ppp.push(&mut new_stream); } @@ -366,9 +375,11 @@ impl Recv Ok(()) } - pub fn recv_reset(&mut self, frame: frame::Reset, stream: &mut Stream) - -> Result<(), RecvError> - { + pub fn recv_reset( + &mut self, + frame: frame::Reset, + stream: &mut Stream, + ) -> Result<(), RecvError> { let err = proto::Error::Proto(frame.reason()); // Notify the stream @@ -387,9 +398,7 @@ impl Recv } /// Returns true if the remote peer can initiate a stream with the given ID. - fn ensure_can_open(&self, id: StreamId) - -> Result<(), RecvError> - { + fn ensure_can_open(&self, id: StreamId) -> Result<(), RecvError> { if !P::is_server() { // Remote is a server and cannot open streams. PushPromise is // registered by reserving, so does not go through this path. @@ -405,9 +414,7 @@ impl Recv } /// Returns true if the remote peer can reserve a stream with the given ID. - fn ensure_can_reserve(&self, promised_id: StreamId) - -> Result<(), RecvError> - { + fn ensure_can_reserve(&self, promised_id: StreamId) -> Result<(), RecvError> { // TODO: Are there other rules? if P::is_server() { // The remote is a client and cannot reserve @@ -422,9 +429,12 @@ impl Recv } /// Send any pending refusals. - pub fn send_pending_refusal(&mut self, dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn send_pending_refusal( + &mut self, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { if let Some(stream_id) = self.refused { try_ready!(dst.poll_ready()); @@ -433,7 +443,9 @@ impl Recv let frame = frame::Reset::new(stream_id, RefusedStream); // Buffer the frame - dst.buffer(frame.into()).ok().expect("invalid RST_STREAM frame"); + dst.buffer(frame.into()) + .ok() + .expect("invalid RST_STREAM frame"); } self.refused = None; @@ -441,11 +453,13 @@ impl Recv Ok(Async::Ready(())) } - pub fn poll_complete(&mut self, - store: &mut Store, - dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn poll_complete( + &mut self, + store: &mut Store, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { // Send any pending connection level window updates try_ready!(self.send_connection_window_update(dst)); @@ -457,9 +471,12 @@ impl Recv } /// Send connection level window update - fn send_connection_window_update(&mut self, dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + fn send_connection_window_update( + &mut self, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { if let Some(incr) = self.flow.unclaimed_capacity() { let frame = frame::WindowUpdate::new(StreamId::zero(), incr); @@ -468,10 +485,15 @@ impl Recv try_ready!(dst.poll_ready()); // Buffer the WINDOW_UPDATE frame - dst.buffer(frame.into()).ok().expect("invalid WINDOW_UPDATE frame"); + dst.buffer(frame.into()) + .ok() + .expect("invalid WINDOW_UPDATE frame"); // Update flow control - self.flow.inc_window(incr).ok().expect("unexpected flow control state"); + self.flow + .inc_window(incr) + .ok() + .expect("unexpected flow control state"); } Ok(().into()) @@ -479,11 +501,13 @@ impl Recv /// Send stream level window update - pub fn send_stream_window_updates(&mut self, - store: &mut Store, - dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn send_stream_window_updates( + &mut self, + store: &mut Store, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { loop { // Ensure the codec has capacity @@ -507,27 +531,28 @@ impl Recv let frame = frame::WindowUpdate::new(stream.id, incr); // Buffer it - dst.buffer(frame.into()).ok().expect("invalid WINDOW_UPDATE frame"); + dst.buffer(frame.into()) + .ok() + .expect("invalid WINDOW_UPDATE frame"); // Update flow control - stream.recv_flow.inc_window(incr).ok().expect("unexpected flow control state"); + stream + .recv_flow + .inc_window(incr) + .ok() + .expect("unexpected flow control state"); } } } pub fn next_incoming(&mut self, store: &mut Store) -> Option { - self.pending_accept.pop(store) - .map(|ptr| ptr.key()) + self.pending_accept.pop(store).map(|ptr| ptr.key()) } - pub fn poll_data(&mut self, stream: &mut Stream) - -> Poll, proto::Error> - { + pub fn poll_data(&mut self, stream: &mut Stream) -> Poll, proto::Error> { // TODO: Return error when the stream is reset match stream.pending_recv.pop_front(&mut self.buffer) { - Some(Event::Data(payload)) => { - Ok(Some(payload).into()) - } + Some(Event::Data(payload)) => Ok(Some(payload).into()), Some(event) => { // Frame is trailer stream.pending_recv.push_front(&mut self.buffer, event); @@ -548,13 +573,12 @@ impl Recv } } - pub fn poll_trailers(&mut self, stream: &mut Stream) - -> Poll, proto::Error> - { + pub fn poll_trailers( + &mut self, + stream: &mut Stream, + ) -> Poll, proto::Error> { match stream.pending_recv.pop_front(&mut self.buffer) { - Some(Event::Trailers(trailers)) => { - Ok(Some(trailers).into()) - } + Some(Event::Trailers(trailers)) => Ok(Some(trailers).into()), Some(_) => { // TODO: This is a user error. `poll_trailers` was called before // the entire set of data frames have been consumed. What should @@ -576,12 +600,11 @@ impl Recv } impl Recv - where B: Buf, +where + B: Buf, { /// TODO: Should this fn return `Result`? - pub fn take_request(&mut self, stream: &mut store::Ptr) - -> Request<()> - { + pub fn take_request(&mut self, stream: &mut store::Ptr) -> Request<()> { match stream.pending_recv.pop_front(&mut self.buffer) { Some(Event::Headers(request)) => request, _ => panic!(), @@ -590,16 +613,17 @@ impl Recv } impl Recv - where B: Buf, +where + B: Buf, { - pub fn poll_response(&mut self, stream: &mut store::Ptr) - -> Poll, proto::Error> { + pub fn poll_response( + &mut self, + stream: &mut store::Ptr, + ) -> Poll, proto::Error> { // If the buffer is not empty, then the first frame must be a HEADERS // frame or the user violated the contract. match stream.pending_recv.pop_front(&mut self.buffer) { - Some(Event::Headers(response)) => { - Ok(response.into()) - } + Some(Event::Headers(response)) => Ok(response.into()), Some(_) => unimplemented!(), None => { stream.state.ensure_recv_open()?; diff --git a/src/proto/streams/send.rs b/src/proto/streams/send.rs index f61f61a..ada5553 100644 --- a/src/proto/streams/send.rs +++ b/src/proto/streams/send.rs @@ -1,8 +1,8 @@ -use frame::{self, Reason}; +use super::*; use codec::{RecvError, UserError}; use codec::UserError::*; +use frame::{self, Reason}; use proto::*; -use super::*; use bytes::Buf; @@ -11,7 +11,8 @@ use std::io; /// Manages state transitions related to outbound frames. #[derive(Debug)] pub(super) struct Send - where P: Peer, +where + P: Peer, { /// Stream identifier to use for next initialized stream. next_stream_id: StreamId, @@ -24,8 +25,9 @@ pub(super) struct Send } impl Send -where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { /// Create a new `Send` pub fn new(config: &Config) -> Self { @@ -46,10 +48,8 @@ where B: Buf, /// Update state reflecting a new, locally opened stream /// /// Returns the stream state if successful. `None` if refused - pub fn open(&mut self, counts: &mut Counts

) - -> Result - { - try!(self.ensure_can_open()); + pub fn open(&mut self, counts: &mut Counts

) -> Result { + self.ensure_can_open()?; if !counts.can_inc_num_send_streams() { return Err(Rejected.into()); @@ -64,13 +64,15 @@ where B: Buf, Ok(ret) } - pub fn send_headers(&mut self, - frame: frame::Headers, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), UserError> - { - trace!("send_headers; frame={:?}; init_window={:?}", frame, self.init_window_sz); + pub fn send_headers( + &mut self, + frame: frame::Headers, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), UserError> { + trace!("send_headers; frame={:?}; init_window={:?}", + frame, + self.init_window_sz); let end_stream = frame.is_end_stream(); @@ -83,11 +85,12 @@ where B: Buf, Ok(()) } - pub fn send_reset(&mut self, - reason: Reason, - stream: &mut store::Ptr, - task: &mut Option) - { + pub fn send_reset( + &mut self, + reason: Reason, + stream: &mut store::Ptr, + task: &mut Option, + ) { if stream.state.is_reset() { // Don't double reset return; @@ -116,24 +119,25 @@ where B: Buf, self.prioritize.queue_frame(frame.into(), stream, task); // Re-assign all capacity to the connection - self.prioritize.assign_connection_capacity(available, stream); + self.prioritize + .assign_connection_capacity(available, stream); } - pub fn send_data(&mut self, - frame: frame::Data, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), UserError> - { + pub fn send_data( + &mut self, + frame: frame::Data, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), UserError> { self.prioritize.send_data(frame, stream, task) } - pub fn send_trailers(&mut self, - frame: frame::Headers, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), UserError> - { + pub fn send_trailers( + &mut self, + frame: frame::Headers, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), UserError> { // TODO: Should this logic be moved into state.rs? if !stream.state.is_send_streaming() { return Err(UnexpectedFrameType.into()); @@ -150,12 +154,14 @@ where B: Buf, Ok(()) } - pub fn poll_complete(&mut self, - store: &mut Store, - counts: &mut Counts

, - dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn poll_complete( + &mut self, + store: &mut Store, + counts: &mut Counts

, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { self.prioritize.poll_complete(store, counts, dst) } @@ -165,9 +171,10 @@ where B: Buf, self.prioritize.reserve_capacity(capacity, stream) } - pub fn poll_capacity(&mut self, stream: &mut store::Ptr) - -> Poll, UserError> - { + pub fn poll_capacity( + &mut self, + stream: &mut store::Ptr, + ) -> Poll, UserError> { if !stream.state.is_send_streaming() { return Ok(Async::Ready(None)); } @@ -193,20 +200,21 @@ where B: Buf, } } - pub fn recv_connection_window_update(&mut self, - frame: frame::WindowUpdate, - store: &mut Store) - -> Result<(), Reason> - { - self.prioritize.recv_connection_window_update(frame.size_increment(), store) + pub fn recv_connection_window_update( + &mut self, + frame: frame::WindowUpdate, + store: &mut Store, + ) -> Result<(), Reason> { + self.prioritize + .recv_connection_window_update(frame.size_increment(), store) } - pub fn recv_stream_window_update(&mut self, - sz: WindowSize, - stream: &mut store::Ptr, - task: &mut Option) - -> Result<(), Reason> - { + pub fn recv_stream_window_update( + &mut self, + sz: WindowSize, + stream: &mut store::Ptr, + task: &mut Option, + ) -> Result<(), Reason> { if let Err(e) = self.prioritize.recv_stream_window_update(sz, stream) { debug!("recv_stream_window_update !!; err={:?}", e); self.send_reset(FlowControlError.into(), stream, task); @@ -217,12 +225,12 @@ where B: Buf, Ok(()) } - pub fn apply_remote_settings(&mut self, - settings: &frame::Settings, - store: &mut Store, - task: &mut Option) - -> Result<(), RecvError> - { + pub fn apply_remote_settings( + &mut self, + settings: &frame::Settings, + store: &mut Store, + task: &mut Option, + ) -> Result<(), RecvError> { // Applies an update to the remote endpoint's initial window size. // // Per RFC 7540 §6.9.2: @@ -254,7 +262,9 @@ where B: Buf, stream.send_flow.dec_window(dec); trace!("decremented stream window; id={:?}; decr={}; flow={:?}", - stream.id, dec, stream.send_flow); + stream.id, + dec, + stream.send_flow); // TODO: Probably try to assign capacity? diff --git a/src/proto/streams/state.rs b/src/proto/streams/state.rs index ce31f55..6bd8009 100644 --- a/src/proto/streams/state.rs +++ b/src/proto/streams/state.rs @@ -1,7 +1,7 @@ -use frame::Reason; -use frame::Reason::*; use codec::{RecvError, UserError}; use codec::UserError::*; +use frame::Reason; +use frame::Reason::*; use proto; use self::Inner::*; @@ -58,10 +58,7 @@ enum Inner { // TODO: these states shouldn't count against concurrency limits: //ReservedLocal, ReservedRemote, - Open { - local: Peer, - remote: Peer, - }, + Open { local: Peer, remote: Peer }, HalfClosedLocal(Peer), // TODO: explicitly name this value HalfClosedRemote(Peer), // When reset, a reason is provided @@ -96,7 +93,10 @@ impl State { } } } - Open { local: AwaitingHeaders, remote } => { + Open { + local: AwaitingHeaders, + remote, + } => { if eos { HalfClosedLocal(remote) } else { @@ -155,7 +155,10 @@ impl State { } } } - Open { local, remote: AwaitingHeaders } => { + Open { + local, + remote: AwaitingHeaders, + } => { if eos { HalfClosedRemote(local) } else { @@ -195,7 +198,9 @@ impl State { /// Indicates that the remote side will not send more data to the local. pub fn recv_close(&mut self) -> Result<(), RecvError> { match self.inner { - Open { local, .. } => { + Open { + local, .. + } => { // The remote side will continue to receive data. trace!("recv_close: Open => HalfClosedRemote({:?})", local); self.inner = HalfClosedRemote(local); @@ -218,9 +223,9 @@ impl State { _ => { trace!("recv_err; err={:?}", err); self.inner = Closed(match *err { - Proto(reason) => Some(Cause::Proto(reason)), - Io(..) => Some(Cause::Io), - }); + Proto(reason) => Some(Cause::Proto(reason)), + Io(..) => Some(Cause::Io), + }); } } } @@ -228,7 +233,9 @@ impl State { /// Indicates that the local side will not send more data to the local. pub fn send_close(&mut self) { match self.inner { - Open { remote, .. } => { + Open { + remote, .. + } => { // The remote side will continue to receive data. trace!("send_close: Open => HalfClosedLocal({:?})", remote); self.inner = HalfClosedLocal(remote); @@ -259,7 +266,9 @@ impl State { /// concurrency limit. pub fn is_counted(&self) -> bool { match self.inner { - Open { .. } => true, + Open { + .. + } => true, HalfClosedLocal(..) => true, HalfClosedRemote(..) => true, _ => false, @@ -268,7 +277,10 @@ impl State { pub fn is_send_streaming(&self) -> bool { match self.inner { - Open { local: Peer::Streaming, .. } => true, + Open { + local: Peer::Streaming, + .. + } => true, HalfClosedRemote(Peer::Streaming) => true, _ => false, } @@ -278,7 +290,10 @@ impl State { pub fn is_recv_headers(&self) -> bool { match self.inner { Idle => true, - Open { remote: AwaitingHeaders, .. } => true, + Open { + remote: AwaitingHeaders, + .. + } => true, HalfClosedLocal(AwaitingHeaders) => true, _ => false, } @@ -286,7 +301,10 @@ impl State { pub fn is_recv_streaming(&self) -> bool { match self.inner { - Open { remote: Peer::Streaming, .. } => true, + Open { + remote: Peer::Streaming, + .. + } => true, HalfClosedLocal(Peer::Streaming) => true, _ => false, } @@ -311,12 +329,8 @@ impl State { // TODO: Is this correct? match self.inner { - Closed(Some(Cause::Proto(reason))) => { - Err(proto::Error::Proto(reason)) - } - Closed(Some(Cause::Io)) => { - Err(proto::Error::Io(io::ErrorKind::BrokenPipe.into())) - } + Closed(Some(Cause::Proto(reason))) => Err(proto::Error::Proto(reason)), + Closed(Some(Cause::Io)) => Err(proto::Error::Io(io::ErrorKind::BrokenPipe.into())), _ => Ok(()), } } @@ -324,7 +338,9 @@ impl State { impl Default for State { fn default() -> State { - State { inner: Inner::Idle } + State { + inner: Inner::Idle, + } } } diff --git a/src/proto/streams/store.rs b/src/proto/streams/store.rs index 1446fdc..a90b199 100644 --- a/src/proto/streams/store.rs +++ b/src/proto/streams/store.rs @@ -4,13 +4,14 @@ use slab; use ordermap::{self, OrderMap}; -use std::ops; use std::marker::PhantomData; +use std::ops; /// Storage for streams #[derive(Debug)] pub(super) struct Store - where P: Peer, +where + P: Peer, { slab: slab::Slab>, ids: OrderMap, @@ -18,7 +19,8 @@ pub(super) struct Store /// "Pointer" to an entry in the store pub(super) struct Ptr<'a, B: 'a, P> - where P: Peer + 'a, +where + P: Peer + 'a, { key: Key, store: &'a mut Store, @@ -30,7 +32,8 @@ pub(super) struct Key(usize); #[derive(Debug)] pub(super) struct Queue - where P: Peer, +where + P: Peer, { indices: Option, _p: PhantomData<(B, N, P)>, @@ -65,14 +68,16 @@ pub(super) struct OccupiedEntry<'a> { } pub(super) struct VacantEntry<'a, B: 'a, P> - where P: Peer + 'a, +where + P: Peer + 'a, { ids: ordermap::VacantEntry<'a, StreamId, usize>, slab: &'a mut slab::Slab>, } pub(super) trait Resolve - where P: Peer, +where + P: Peer, { fn resolve(&mut self, key: Key) -> Ptr; } @@ -80,7 +85,8 @@ pub(super) trait Resolve // ===== impl Store ===== impl Store - where P: Peer, +where + P: Peer, { pub fn new() -> Self { Store { @@ -100,9 +106,9 @@ impl Store }; Some(Ptr { - key: Key(key), - store: self, - }) + key: Key(key), + store: self, + }) } pub fn insert(&mut self, id: StreamId, val: Stream) -> Ptr { @@ -121,20 +127,21 @@ impl Store match self.ids.entry(id) { Occupied(e) => { Entry::Occupied(OccupiedEntry { - ids: e, - }) + ids: e, + }) } Vacant(e) => { Entry::Vacant(VacantEntry { - ids: e, - slab: &mut self.slab, - }) + ids: e, + slab: &mut self.slab, + }) } } } pub fn for_each(&mut self, mut f: F) -> Result<(), E> - where F: FnMut(Ptr) -> Result<(), E>, + where + F: FnMut(Ptr) -> Result<(), E>, { let mut len = self.ids.len(); let mut i = 0; @@ -144,9 +151,9 @@ impl Store let key = *self.ids.get_index(i).unwrap().1; f(Ptr { - key: Key(key), - store: self, - })?; + key: Key(key), + store: self, + })?; // TODO: This logic probably could be better... let new_len = self.ids.len(); @@ -164,7 +171,8 @@ impl Store } impl Resolve for Store - where P: Peer, +where + P: Peer, { fn resolve(&mut self, key: Key) -> Ptr { Ptr { @@ -175,7 +183,8 @@ impl Resolve for Store } impl ops::Index for Store - where P: Peer, +where + P: Peer, { type Output = Stream; @@ -185,7 +194,8 @@ impl ops::Index for Store } impl ops::IndexMut for Store - where P: Peer, +where + P: Peer, { fn index_mut(&mut self, key: Key) -> &mut Self::Output { self.slab.index_mut(key.0) @@ -194,7 +204,8 @@ impl ops::IndexMut for Store #[cfg(feature = "unstable")] impl Store - where P: Peer, +where + P: Peer, { pub fn num_active_streams(&self) -> usize { self.ids.len() @@ -208,8 +219,9 @@ impl Store // ===== impl Queue ===== impl Queue - where N: Next, - P: Peer, +where + N: Next, + P: Peer, { pub fn new() -> Self { Queue { @@ -260,9 +272,9 @@ impl Queue None => { trace!(" -> first entry"); self.indices = Some(store::Indices { - head: stream.key(), - tail: stream.key(), - }); + head: stream.key(), + tail: stream.key(), + }); } } @@ -270,7 +282,8 @@ impl Queue } pub fn pop<'a, R>(&mut self, store: &'a mut R) -> Option> - where R: Resolve + where + R: Resolve, { if let Some(mut idxs) = self.indices { let mut stream = store.resolve(idxs.head); @@ -296,7 +309,8 @@ impl Queue // ===== impl Ptr ===== impl<'a, B: 'a, P> Ptr<'a, B, P> - where P: Peer, +where + P: Peer, { /// Returns the Key associated with the stream pub fn key(&self) -> Key { @@ -323,7 +337,8 @@ impl<'a, B: 'a, P> Ptr<'a, B, P> } impl<'a, B: 'a, P> Resolve for Ptr<'a, B, P> - where P: Peer, +where + P: Peer, { fn resolve(&mut self, key: Key) -> Ptr { Ptr { @@ -334,7 +349,8 @@ impl<'a, B: 'a, P> Resolve for Ptr<'a, B, P> } impl<'a, B: 'a, P> ops::Deref for Ptr<'a, B, P> - where P: Peer, +where + P: Peer, { type Target = Stream; @@ -344,7 +360,8 @@ impl<'a, B: 'a, P> ops::Deref for Ptr<'a, B, P> } impl<'a, B: 'a, P> ops::DerefMut for Ptr<'a, B, P> - where P: Peer, +where + P: Peer, { fn deref_mut(&mut self) -> &mut Stream { &mut self.store.slab[self.key.0] @@ -362,7 +379,8 @@ impl<'a> OccupiedEntry<'a> { // ===== impl VacantEntry ===== impl<'a, B, P> VacantEntry<'a, B, P> - where P: Peer, +where + P: Peer, { pub fn insert(self, value: Stream) -> Key { // Insert the value in the slab diff --git a/src/proto/streams/stream.rs b/src/proto/streams/stream.rs index b341a62..df80168 100644 --- a/src/proto/streams/stream.rs +++ b/src/proto/streams/stream.rs @@ -15,7 +15,8 @@ use std::usize; /// Thus, `ref_count` can be zero and the stream still has to be kept around. #[derive(Debug)] pub(super) struct Stream - where P: Peer, +where + P: Peer, { /// The h2 stream identifier pub id: StreamId, @@ -27,7 +28,6 @@ pub(super) struct Stream pub ref_count: usize, // ===== Fields related to sending ===== - /// Next node in the accept linked list pub next_pending_send: Option, @@ -61,7 +61,6 @@ pub(super) struct Stream pub send_capacity_inc: bool, // ===== Fields related to receiving ===== - /// Next node in the accept linked list pub next_pending_accept: Option, @@ -90,7 +89,6 @@ pub(super) struct Stream /// Validate content-length headers pub content_length: ContentLength, - } /// State related to validating a stream's content-length @@ -114,21 +112,27 @@ pub(super) struct NextSendCapacity; pub(super) struct NextWindowUpdate; impl Stream - where P: Peer, +where + P: Peer, { - pub fn new(id: StreamId, - init_send_window: WindowSize, - init_recv_window: WindowSize) -> Stream - { + pub fn new( + id: StreamId, + init_send_window: WindowSize, + init_recv_window: WindowSize, + ) -> Stream { let mut send_flow = FlowControl::new(); let mut recv_flow = FlowControl::new(); - recv_flow.inc_window(init_recv_window) - .ok().expect("invalid initial receive window"); + recv_flow + .inc_window(init_recv_window) + .ok() + .expect("invalid initial receive window"); recv_flow.assign_capacity(init_recv_window); - send_flow.inc_window(init_send_window) - .ok().expect("invalid initial send window size"); + send_flow + .inc_window(init_send_window) + .ok() + .expect("invalid initial send window size"); Stream { id, @@ -136,7 +140,6 @@ impl Stream ref_count: 0, // ===== Fields related to sending ===== - next_pending_send: None, is_pending_send: false, send_flow: send_flow, @@ -149,7 +152,6 @@ impl Stream send_capacity_inc: false, // ===== Fields related to receiving ===== - next_pending_accept: None, is_pending_accept: false, recv_flow: recv_flow, @@ -197,10 +199,8 @@ impl Stream // There are no more outstanding references to the stream self.ref_count == 0 && // The stream is not in any queue - !self.is_pending_send && - !self.is_pending_send_capacity && - !self.is_pending_accept && - !self.is_pending_window_update + !self.is_pending_send && !self.is_pending_send_capacity && + !self.is_pending_accept && !self.is_pending_window_update } pub fn assign_capacity(&mut self, capacity: WindowSize) { diff --git a/src/proto/streams/streams.rs b/src/proto/streams/streams.rs index 1e419ba..82a1c20 100644 --- a/src/proto/streams/streams.rs +++ b/src/proto/streams/streams.rs @@ -1,9 +1,9 @@ -use {client, server, proto}; -use frame::Reason; -use codec::{SendError, RecvError, UserError}; -use proto::*; use super::*; use super::store::Resolve; +use {client, proto, server}; +use codec::{RecvError, SendError, UserError}; +use frame::Reason; +use proto::*; use http::HeaderMap; @@ -12,7 +12,8 @@ use std::sync::{Arc, Mutex}; #[derive(Debug)] pub(crate) struct Streams - where P: Peer, +where + P: Peer, { inner: Arc>>, } @@ -20,7 +21,8 @@ pub(crate) struct Streams /// Reference to the stream state #[derive(Debug)] pub(crate) struct StreamRef - where P: Peer, +where + P: Peer, { inner: Arc>>, key: store::Key, @@ -32,7 +34,8 @@ pub(crate) struct StreamRef /// TODO: better name #[derive(Debug)] struct Inner - where P: Peer, +where + P: Peer, { /// Tracks send & recv stream concurrency. counts: Counts

, @@ -42,7 +45,8 @@ struct Inner #[derive(Debug)] struct Actions - where P: Peer, +where + P: Peer, { /// Manages state transitions initiated by receiving frames recv: Recv, @@ -55,27 +59,26 @@ struct Actions } impl Streams - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { pub fn new(config: Config) -> Self { Streams { inner: Arc::new(Mutex::new(Inner { - counts: Counts::new(&config), - actions: Actions { - recv: Recv::new(&config), - send: Send::new(&config), - task: None, - }, - store: Store::new(), - })), + counts: Counts::new(&config), + actions: Actions { + recv: Recv::new(&config), + send: Send::new(&config), + task: None, + }, + store: Store::new(), + })), } } /// Process inbound headers - pub fn recv_headers(&mut self, frame: frame::Headers) - -> Result<(), RecvError> - { + pub fn recv_headers(&mut self, frame: frame::Headers) -> Result<(), RecvError> { let id = frame.stream_id(); let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -83,12 +86,11 @@ impl Streams let key = match me.store.find_entry(id) { Entry::Occupied(e) => e.key(), Entry::Vacant(e) => { - match try!(me.actions.recv.open(id, &mut me.counts)) { + match me.actions.recv.open(id, &mut me.counts)? { Some(stream_id) => { - let stream = Stream::new( - stream_id, - me.actions.send.init_window_sz(), - me.actions.recv.init_window_sz()); + let stream = Stream::new(stream_id, + me.actions.send.init_window_sz(), + me.actions.recv.init_window_sz()); e.insert(stream) } @@ -101,7 +103,9 @@ impl Streams let actions = &mut me.actions; me.counts.transition(stream, |counts, stream| { - trace!("recv_headers; stream={:?}; state={:?}", stream.id, stream.state); + trace!("recv_headers; stream={:?}; state={:?}", + stream.id, + stream.state); let res = if stream.state.is_recv_headers() { actions.recv.recv_headers(frame, stream, counts) @@ -118,9 +122,7 @@ impl Streams }) } - pub fn recv_data(&mut self, frame: frame::Data) - -> Result<(), RecvError> - { + pub fn recv_data(&mut self, frame: frame::Data) -> Result<(), RecvError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -139,9 +141,7 @@ impl Streams }) } - pub fn recv_reset(&mut self, frame: frame::Reset) - -> Result<(), RecvError> - { + pub fn recv_reset(&mut self, frame: frame::Reset) -> Result<(), RecvError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -155,7 +155,8 @@ impl Streams Some(stream) => stream, None => { // TODO: Are there other error cases? - me.actions.ensure_not_idle(id) + me.actions + .ensure_not_idle(id) .map_err(RecvError::Connection)?; return Ok(()); @@ -181,26 +182,27 @@ impl Streams let last_processed_id = actions.recv.last_processed_id(); - me.store.for_each(|stream| { - counts.transition(stream, |_, stream| { - actions.recv.recv_err(err, &mut *stream); - Ok::<_, ()>(()) + me.store + .for_each(|stream| { + counts.transition(stream, |_, stream| { + actions.recv.recv_err(err, &mut *stream); + Ok::<_, ()>(()) + }) }) - }).unwrap(); + .unwrap(); last_processed_id } - pub fn recv_window_update(&mut self, frame: frame::WindowUpdate) - -> Result<(), RecvError> - { + pub fn recv_window_update(&mut self, frame: frame::WindowUpdate) -> Result<(), RecvError> { let id = frame.stream_id(); let mut me = self.inner.lock().unwrap(); let me = &mut *me; if id.is_zero() { - me.actions.send.recv_connection_window_update( - frame, &mut me.store) + me.actions + .send + .recv_connection_window_update(frame, &mut me.store) .map_err(RecvError::Connection)?; } else { // The remote may send window updates for streams that the local now @@ -209,12 +211,15 @@ impl Streams // This result is ignored as there is nothing to do when there // is an error. The stream is reset by the function on error and // the error is informational. - let _ = me.actions.send.recv_stream_window_update( - frame.size_increment(), - &mut stream, - &mut me.actions.task); + let _ = me.actions + .send + .recv_stream_window_update(frame.size_increment(), + &mut stream, + &mut me.actions.task); } else { - me.actions.recv.ensure_not_idle(id) + me.actions + .recv + .ensure_not_idle(id) .map_err(RecvError::Connection)?; } } @@ -222,9 +227,7 @@ impl Streams Ok(()) } - pub fn recv_push_promise(&mut self, frame: frame::PushPromise) - -> Result<(), RecvError> - { + pub fn recv_push_promise(&mut self, frame: frame::PushPromise) -> Result<(), RecvError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -235,8 +238,9 @@ impl Streams None => return Err(RecvError::Connection(ProtocolError)), }; - me.actions.recv.recv_push_promise( - frame, &me.actions.send, stream, &mut me.store) + me.actions + .recv + .recv_push_promise(frame, &me.actions.send, stream, &mut me.store) } pub fn next_incoming(&mut self) -> Option> { @@ -264,18 +268,21 @@ impl Streams }) } - pub fn send_pending_refusal(&mut self, dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn send_pending_refusal( + &mut self, + dst: &mut Codec>, + ) -> Poll<(), io::Error> + where + T: AsyncWrite, { let mut me = self.inner.lock().unwrap(); let me = &mut *me; me.actions.recv.send_pending_refusal(dst) } - pub fn poll_complete(&mut self, dst: &mut Codec>) - -> Poll<(), io::Error> - where T: AsyncWrite, + pub fn poll_complete(&mut self, dst: &mut Codec>) -> Poll<(), io::Error> + where + T: AsyncWrite, { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -287,7 +294,9 @@ impl Streams try_ready!(me.actions.recv.poll_complete(&mut me.store, dst)); // Send any other pending frames - try_ready!(me.actions.send.poll_complete(&mut me.store, &mut me.counts, dst)); + try_ready!(me.actions + .send + .poll_complete(&mut me.store, &mut me.counts, dst)); // Nothing else to do, track the task me.actions.task = Some(task::current()); @@ -295,21 +304,22 @@ impl Streams Ok(().into()) } - pub fn apply_remote_settings(&mut self, frame: &frame::Settings) - -> Result<(), RecvError> - { + pub fn apply_remote_settings(&mut self, frame: &frame::Settings) -> Result<(), RecvError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; me.counts.apply_remote_settings(frame); - me.actions.send.apply_remote_settings( - frame, &mut me.store, &mut me.actions.task) + me.actions + .send + .apply_remote_settings(frame, &mut me.store, &mut me.actions.task) } - pub fn send_request(&mut self, request: Request<()>, end_of_stream: bool) - -> Result, SendError> - { + pub fn send_request( + &mut self, + request: Request<()>, + end_of_stream: bool, + ) -> Result, SendError> { use http::Method; use super::stream::ContentLength; @@ -325,23 +335,22 @@ impl Streams // Initialize a new stream. This fails if the connection is at capacity. let stream_id = me.actions.send.open(&mut me.counts)?; - let mut stream = Stream::new( - stream_id, - me.actions.send.init_window_sz(), - me.actions.recv.init_window_sz()); + let mut stream = Stream::new(stream_id, + me.actions.send.init_window_sz(), + me.actions.recv.init_window_sz()); if *request.method() == Method::HEAD { stream.content_length = ContentLength::Head; } // Convert the message - let headers = client::Peer::convert_send_message( - stream_id, request, end_of_stream); + let headers = client::Peer::convert_send_message(stream_id, request, end_of_stream); let mut stream = me.store.insert(stream.id, stream); - me.actions.send.send_headers( - headers, &mut stream, &mut me.actions.task)?; + me.actions + .send + .send_headers(headers, &mut stream, &mut me.actions.task)?; // Given that the stream has been initialized, it should not be in the // closed state. @@ -354,9 +363,9 @@ impl Streams }; Ok(StreamRef { - inner: self.inner.clone(), - key: key, - }) + inner: self.inner.clone(), + key: key, + }) } pub fn send_reset(&mut self, id: StreamId, reason: Reason) { @@ -368,8 +377,7 @@ impl Streams Entry::Vacant(e) => { match me.actions.recv.open(id, &mut me.counts) { Ok(Some(stream_id)) => { - let stream = Stream::new( - stream_id, 0, 0); + let stream = Stream::new(stream_id, 0, 0); e.insert(stream) } @@ -388,7 +396,8 @@ impl Streams } impl Streams - where B: Buf, +where + B: Buf, { pub fn poll_send_request_ready(&mut self) -> Async<()> { let mut me = self.inner.lock().unwrap(); @@ -400,8 +409,9 @@ impl Streams #[cfg(feature = "unstable")] impl Streams - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { pub fn num_active_streams(&self) -> usize { let me = self.inner.lock().unwrap(); @@ -417,12 +427,11 @@ impl Streams // ===== impl StreamRef ===== impl StreamRef - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { - pub fn send_data(&mut self, data: B, end_stream: bool) - -> Result<(), UserError> - { + pub fn send_data(&mut self, data: B, end_stream: bool) -> Result<(), UserError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -439,9 +448,7 @@ impl StreamRef }) } - pub fn send_trailers(&mut self, trailers: HeaderMap) - -> Result<(), UserError> - { + pub fn send_trailers(&mut self, trailers: HeaderMap) -> Result<(), UserError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -469,9 +476,11 @@ impl StreamRef }) } - pub fn send_response(&mut self, response: Response<()>, end_of_stream: bool) - -> Result<(), UserError> - { + pub fn send_response( + &mut self, + response: Response<()>, + end_of_stream: bool, + ) -> Result<(), UserError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; @@ -479,8 +488,7 @@ impl StreamRef let actions = &mut me.actions; me.counts.transition(stream, |_, stream| { - let frame = server::Peer::convert_send_message( - stream.id, response, end_of_stream); + let frame = server::Peer::convert_send_message(stream.id, response, end_of_stream); actions.send.send_headers(frame, stream, &mut actions.task) }) @@ -515,16 +523,15 @@ impl StreamRef /// Releases recv capacity back to the peer. This may result in sending /// WINDOW_UPDATE frames on both the stream and connection. - pub fn release_capacity(&mut self, capacity: WindowSize) - -> Result<(), UserError> - { + pub fn release_capacity(&mut self, capacity: WindowSize) -> Result<(), UserError> { let mut me = self.inner.lock().unwrap(); let me = &mut *me; let mut stream = me.store.resolve(self.key); - me.actions.recv.release_capacity( - capacity, &mut stream, &mut me.actions.task) + me.actions + .recv + .release_capacity(capacity, &mut stream, &mut me.actions.task) } /// Request capacity to send data @@ -559,7 +566,8 @@ impl StreamRef } impl StreamRef - where B: Buf, +where + B: Buf, { /// Called by the server after the stream is accepted. Given that clients /// initialize streams by sending HEADERS, the request will always be @@ -578,7 +586,8 @@ impl StreamRef } impl StreamRef - where B: Buf, +where + B: Buf, { pub fn poll_response(&mut self) -> Poll, proto::Error> { let mut me = self.inner.lock().unwrap(); @@ -591,13 +600,12 @@ impl StreamRef } impl Clone for StreamRef - where P: Peer, +where + P: Peer, { fn clone(&self) -> Self { // Increment the ref count - self.inner.lock().unwrap() - .store.resolve(self.key) - .ref_inc(); + self.inner.lock().unwrap().store.resolve(self.key).ref_inc(); StreamRef { inner: self.inner.clone(), @@ -607,7 +615,8 @@ impl Clone for StreamRef } impl Drop for StreamRef - where P: Peer, +where + P: Peer, { fn drop(&mut self) { let mut me = self.inner.lock().unwrap(); @@ -632,16 +641,19 @@ impl Drop for StreamRef // ===== impl Actions ===== impl Actions - where B: Buf, - P: Peer, +where + B: Buf, + P: Peer, { - - fn reset_on_recv_stream_err(&mut self, - stream: &mut store::Ptr, - res: Result<(), RecvError>) - -> Result<(), RecvError> - { - if let Err(RecvError::Stream { reason, .. }) = res { + fn reset_on_recv_stream_err( + &mut self, + stream: &mut store::Ptr, + res: Result<(), RecvError>, + ) -> Result<(), RecvError> { + if let Err(RecvError::Stream { + reason, .. + }) = res + { // Reset the stream. self.send.send_reset(reason, stream, &mut self.task); Ok(()) @@ -650,9 +662,7 @@ impl Actions } } - fn ensure_not_idle(&mut self, id: StreamId) - -> Result<(), Reason> - { + fn ensure_not_idle(&mut self, id: StreamId) -> Result<(), Reason> { if P::is_local_init(id) { self.send.ensure_not_idle(id) } else { diff --git a/src/server.rs b/src/server.rs index 4c41ee7..293680e 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,12 +1,12 @@ -use frame::{self, StreamId, Reason}; -use frame::Reason::*; use codec::{Codec, RecvError}; +use frame::{self, Reason, StreamId}; +use frame::Reason::*; use proto::{self, Connection, WindowSize}; -use http::{Request, Response, HeaderMap}; -use futures::{self, Future, Poll, Async}; +use bytes::{Buf, Bytes, IntoBuf}; +use futures::{self, Async, Future, Poll}; +use http::{HeaderMap, Request, Response}; use tokio_io::{AsyncRead, AsyncWrite}; -use bytes::{Bytes, Buf, IntoBuf}; use std::fmt; @@ -60,7 +60,8 @@ const PREFACE: [u8; 24] = *b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"; // ===== impl Server ===== impl Server - where T: AsyncRead + AsyncWrite + 'static, +where + T: AsyncRead + AsyncWrite + 'static, { pub fn handshake(io: T) -> Handshake { Server::handshake2(io) @@ -68,8 +69,9 @@ impl Server } impl Server - where T: AsyncRead + AsyncWrite + 'static, - B: IntoBuf + 'static, +where + T: AsyncRead + AsyncWrite + 'static, + B: IntoBuf + 'static, { /// Bind an H2 server connection. /// @@ -82,32 +84,37 @@ impl Server // Create the initial SETTINGS frame let settings = frame::Settings::default(); - // Send initial settings frame - codec.buffer(settings.into()) - .ok().expect("invalid SETTINGS frame"); + // Send initial settings frame + codec + .buffer(settings.into()) + .ok() + .expect("invalid SETTINGS frame"); // Flush pending settings frame and then wait for the client preface let handshake = Flush::new(codec) .and_then(ReadPreface::new) .map(move |codec| { let connection = Connection::new(codec); - Server { connection } - }) - ; + Server { + connection, + } + }); - Handshake { inner: Box::new(handshake) } + Handshake { + inner: Box::new(handshake), + } } /// Returns `Ready` when the underlying connection has closed. pub fn poll_close(&mut self) -> Poll<(), ::Error> { - self.connection.poll() - .map_err(Into::into) + self.connection.poll().map_err(Into::into) } } impl futures::Stream for Server - where T: AsyncRead + AsyncWrite + 'static, - B: IntoBuf + 'static, +where + T: AsyncRead + AsyncWrite + 'static, + B: IntoBuf + 'static, { type Item = (Request>, Stream); type Error = ::Error; @@ -119,7 +126,7 @@ impl futures::Stream for Server Async::Ready(_) => { // If the socket is closed, don't return anything // TODO: drop any pending streams - return Ok(None.into()) + return Ok(None.into()); } _ => {} } @@ -127,10 +134,14 @@ impl futures::Stream for Server if let Some(inner) = self.connection.next_incoming() { trace!("received incoming"); let (head, _) = inner.take_request().into_parts(); - let body = Body { inner: inner.clone() }; + let body = Body { + inner: inner.clone(), + }; let request = Request::from_parts(head, body); - let incoming = Stream { inner }; + let incoming = Stream { + inner, + }; return Ok(Some((request, incoming)).into()); } @@ -140,9 +151,10 @@ impl futures::Stream for Server } impl fmt::Debug for Server - where T: fmt::Debug, - B: fmt::Debug + IntoBuf, - B::Buf: fmt::Debug, +where + T: fmt::Debug, + B: fmt::Debug + IntoBuf, + B::Buf: fmt::Debug, { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("Server") @@ -155,10 +167,13 @@ impl fmt::Debug for Server impl Stream { /// Send a response - pub fn send_response(&mut self, response: Response<()>, end_of_stream: bool) - -> Result<(), ::Error> - { - self.inner.send_response(response, end_of_stream) + pub fn send_response( + &mut self, + response: Response<()>, + end_of_stream: bool, + ) -> Result<(), ::Error> { + self.inner + .send_response(response, end_of_stream) .map_err(Into::into) } @@ -180,19 +195,15 @@ impl Stream { } /// Send a single data frame - pub fn send_data(&mut self, data: B, end_of_stream: bool) - -> Result<(), ::Error> - { - self.inner.send_data(data.into_buf(), end_of_stream) + pub fn send_data(&mut self, data: B, end_of_stream: bool) -> Result<(), ::Error> { + self.inner + .send_data(data.into_buf(), end_of_stream) .map_err(Into::into) } /// Send trailers - pub fn send_trailers(&mut self, trailers: HeaderMap) - -> Result<(), ::Error> - { - self.inner.send_trailers(trailers) - .map_err(Into::into) + pub fn send_trailers(&mut self, trailers: HeaderMap) -> Result<(), ::Error> { + self.inner.send_trailers(trailers).map_err(Into::into) } pub fn send_reset(mut self, reason: Reason) { @@ -202,8 +213,9 @@ impl Stream { impl Stream { /// Send the body - pub fn send(self, src: T, end_of_stream: bool,) -> Send - where T: futures::Stream, + pub fn send(self, src: T, end_of_stream: bool) -> Send + where + T: futures::Stream, { Send { src: src, @@ -223,7 +235,8 @@ impl Body { } pub fn release_capacity(&mut self, sz: usize) -> Result<(), ::Error> { - self.inner.release_capacity(sz as proto::WindowSize) + self.inner + .release_capacity(sz as proto::WindowSize) .map_err(Into::into) } @@ -231,8 +244,7 @@ impl Body { /// /// This function **must** not be called until `Body::poll` returns `None`. pub fn poll_trailers(&mut self) -> Poll, ::Error> { - self.inner.poll_trailers() - .map_err(Into::into) + self.inner.poll_trailers().map_err(Into::into) } } @@ -241,15 +253,15 @@ impl futures::Stream for Body { type Error = ::Error; fn poll(&mut self) -> Poll, Self::Error> { - self.inner.poll_data() - .map_err(Into::into) + self.inner.poll_data().map_err(Into::into) } } // ===== impl Send ===== impl Future for Send - where T: futures::Stream, +where + T: futures::Stream, { type Item = Stream; type Error = ::Error; @@ -303,13 +315,16 @@ impl Future for Send impl Flush { fn new(codec: Codec) -> Self { - Flush { codec: Some(codec) } + Flush { + codec: Some(codec), + } } } impl Future for Flush - where T: AsyncWrite, - B: Buf, +where + T: AsyncWrite, + B: Buf, { type Item = Codec; type Error = ::Error; @@ -337,8 +352,9 @@ impl ReadPreface { } impl Future for ReadPreface - where T: AsyncRead, - B: Buf, +where + T: AsyncRead, + B: Buf, { type Item = Codec; type Error = ::Error; @@ -350,7 +366,7 @@ impl Future for ReadPreface while rem > 0 { let n = try_nb!(self.inner_mut().read(&mut buf[..rem])); - if PREFACE[self.pos..self.pos+n] != buf[..n] { + if PREFACE[self.pos..self.pos + n] != buf[..n] { // TODO: Should this just write the GO_AWAY frame directly? return Err(ProtocolError.into()); } @@ -375,8 +391,9 @@ impl Future for Handshake { } impl fmt::Debug for Handshake - where T: fmt::Debug, - B: fmt::Debug + IntoBuf, +where + T: fmt::Debug, + B: fmt::Debug + IntoBuf, { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "server::Handshake") @@ -394,12 +411,17 @@ impl proto::Peer for Peer { fn convert_send_message( id: StreamId, response: Self::Send, - end_of_stream: bool) -> frame::Headers - { + end_of_stream: bool, + ) -> frame::Headers { use http::response::Parts; // Extract the components of the HTTP request - let (Parts { status, headers, .. }, _) = response.into_parts(); + let (Parts { + status, + headers, + .. + }, + _) = response.into_parts(); // Build the set pseudo header set. All requests will include `method` // and `path`. @@ -415,10 +437,8 @@ impl proto::Peer for Peer { frame } - fn convert_poll_message(headers: frame::Headers) - -> Result - { - use http::{Version, uri}; + fn convert_poll_message(headers: frame::Headers) -> Result { + use http::{uri, Version}; let mut b = Request::builder(); @@ -480,9 +500,9 @@ impl proto::Peer for Peer { // TODO: Should there be more specialized handling for different // kinds of errors return Err(RecvError::Stream { - id: stream_id, - reason: ProtocolError, - }); + id: stream_id, + reason: ProtocolError, + }); } }; diff --git a/tests/client_request.rs b/tests/client_request.rs index 32b57ac..5d2f455 100644 --- a/tests/client_request.rs +++ b/tests/client_request.rs @@ -13,8 +13,7 @@ fn handshake() { .write(SETTINGS_ACK) .build(); - let h2 = Client::handshake(mock) - .wait().unwrap(); + let h2 = Client::handshake(mock).wait().unwrap(); trace!("hands have been shook"); @@ -40,13 +39,13 @@ fn recv_invalid_server_stream_id() { .write(&[0, 0, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); // Send the request let request = Request::builder() .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let stream = h2.request(request, true).unwrap(); @@ -60,19 +59,16 @@ fn recv_invalid_server_stream_id() { #[test] #[ignore] -fn request_without_scheme() { -} +fn request_without_scheme() {} #[test] #[ignore] -fn request_with_h1_version() { -} +fn request_with_h1_version() {} #[test] #[ignore] -fn sending_request_on_closed_soket() { -} +fn sending_request_on_closed_soket() {} const SETTINGS: &'static [u8] = &[0, 0, 0, 4, 0, 0, 0, 0, 0]; const SETTINGS_ACK: &'static [u8] = &[0, 0, 0, 4, 1, 0, 0, 0, 0]; diff --git a/tests/codec_read.rs b/tests/codec_read.rs index a21e1ea..98e6034 100644 --- a/tests/codec_read.rs +++ b/tests/codec_read.rs @@ -6,16 +6,13 @@ use std::error::Error; #[test] fn read_none() { - let mut codec = Codec::from( - mock_io::Builder::new() - .build()); + let mut codec = Codec::from(mock_io::Builder::new().build()); assert_closed!(codec); } #[test] -fn read_frame_too_big() { -} +fn read_frame_too_big() {} // ===== DATA ===== @@ -103,16 +100,13 @@ fn read_data_stream_id_zero() { // ===== HEADERS ===== #[test] -fn read_headers_without_pseudo() { -} +fn read_headers_without_pseudo() {} #[test] -fn read_headers_with_pseudo() { -} +fn read_headers_with_pseudo() {} #[test] -fn read_headers_empty_payload() { -} +fn read_headers_empty_payload() {} #[test] fn update_max_frame_len_at_rest() { @@ -130,5 +124,6 @@ fn update_max_frame_len_at_rest() { codec.set_max_recv_frame_size(2); assert_eq!(codec.max_recv_frame_size(), 2); - assert_eq!(codec.poll().unwrap_err().description(), "frame size too big"); + assert_eq!(codec.poll().unwrap_err().description(), + "frame size too big"); } diff --git a/tests/codec_write.rs b/tests/codec_write.rs index e69de29..8b13789 100644 --- a/tests/codec_write.rs +++ b/tests/codec_write.rs @@ -0,0 +1 @@ + diff --git a/tests/flow_control.rs b/tests/flow_control.rs index ab3e716..5e27ca8 100644 --- a/tests/flow_control.rs +++ b/tests/flow_control.rs @@ -27,13 +27,13 @@ fn send_data_without_requesting_capacity() { .read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let mut stream = h2.request(request, false).unwrap(); @@ -82,14 +82,14 @@ fn release_capacity_sends_window_update() { // gotta end the connection .map(drop); - let h2 = Client::handshake(io).unwrap() - .and_then(|mut h2| { - let request = Request::builder() - .method(Method::GET) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let h2 = Client::handshake(io).unwrap().and_then(|mut h2| { + let request = Request::builder() + .method(Method::GET) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - let req = h2.request(request, true).unwrap() + let req = h2.request(request, true).unwrap() .unwrap() // Get the response .and_then(|resp| { @@ -117,8 +117,8 @@ fn release_capacity_sends_window_update() { assert_eq!(buf.unwrap().len(), payload.len()); Ok(()) }); - h2.unwrap().join(req) - }); + h2.unwrap().join(req) + }); h2.join(mock).wait().unwrap(); } @@ -145,14 +145,14 @@ fn release_capacity_of_small_amount_does_not_send_window_update() { // gotta end the connection .map(drop); - let h2 = Client::handshake(io).unwrap() - .and_then(|mut h2| { - let request = Request::builder() - .method(Method::GET) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let h2 = Client::handshake(io).unwrap().and_then(|mut h2| { + let request = Request::builder() + .method(Method::GET) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - let req = h2.request(request, true).unwrap() + let req = h2.request(request, true).unwrap() .unwrap() // Get the response .and_then(|resp| { @@ -171,20 +171,18 @@ fn release_capacity_of_small_amount_does_not_send_window_update() { assert!(buf.is_none()); Ok(()) }); - h2.unwrap().join(req) - }); + h2.unwrap().join(req) + }); h2.join(mock).wait().unwrap(); } #[test] #[ignore] -fn expand_window_sends_window_update() { -} +fn expand_window_sends_window_update() {} #[test] #[ignore] -fn expand_window_calls_are_coalesced() { -} +fn expand_window_calls_are_coalesced() {} #[test] fn recv_data_overflows_connection_window() { @@ -212,23 +210,23 @@ fn recv_data_overflows_connection_window() { .send_frame(frames::data(1, vec![0u8; 128]).eos()) // expecting goaway for the conn, not stream .recv_frame(frames::go_away(0).flow_control()); - // connection is ended by client + // connection is ended by client - let h2 = Client::handshake(io).unwrap() - .and_then(|mut h2| { - let request = Request::builder() - .method(Method::GET) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let h2 = Client::handshake(io).unwrap().and_then(|mut h2| { + let request = Request::builder() + .method(Method::GET) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - let req = h2.request(request, true).unwrap() - .unwrap() - .and_then(|resp| { - assert_eq!(resp.status(), StatusCode::OK); - let body = resp.into_parts().1; - body.concat2() - .unwrap() - /* FIXME: body stream should error also + let req = h2.request(request, true) + .unwrap() + .unwrap() + .and_then(|resp| { + assert_eq!(resp.status(), StatusCode::OK); + let body = resp.into_parts().1; + body.concat2().unwrap() + /* FIXME: body stream should error also .then(|res| { let err = res.unwrap_err(); assert_eq!( @@ -238,21 +236,18 @@ fn recv_data_overflows_connection_window() { Ok::<(), ()>(()) }) */ - }); - - // client should see a flow control error - let conn = h2.then(|res| { - let err = res.unwrap_err(); - assert_eq!( - err.to_string(), - "protocol error: flow-control protocol violated" - ); - Ok::<(), ()>(()) }); - conn.unwrap().join(req) - }); - h2.join(mock).wait().unwrap(); + // client should see a flow control error + let conn = h2.then(|res| { + let err = res.unwrap_err(); + assert_eq!(err.to_string(), + "protocol error: flow-control protocol violated"); + Ok::<(), ()>(()) + }); + conn.unwrap().join(req) + }); + h2.join(mock).wait().unwrap(); } #[test] @@ -274,52 +269,52 @@ fn stream_close_by_data_frame_releases_capacity() { let window_size = frame::DEFAULT_INITIAL_WINDOW_SIZE as usize; - let h2 = Client::handshake(m).unwrap() - .and_then(|mut h2| { - let request = Request::builder() - .method(Method::POST) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let h2 = Client::handshake(m).unwrap().and_then(|mut h2| { + let request = Request::builder() + .method(Method::POST) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - // Send request - let mut s1 = h2.request(request, false).unwrap(); + // Send request + let mut s1 = h2.request(request, false).unwrap(); - // This effectively reserves the entire connection window - s1.reserve_capacity(window_size); + // This effectively reserves the entire connection window + s1.reserve_capacity(window_size); - // The capacity should be immediately available as nothing else is - // happening on the stream. - assert_eq!(s1.capacity(), window_size); + // The capacity should be immediately available as nothing else is + // happening on the stream. + assert_eq!(s1.capacity(), window_size); - let request = Request::builder() - .method(Method::POST) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let request = Request::builder() + .method(Method::POST) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - // Create a second stream - let mut s2 = h2.request(request, false).unwrap(); + // Create a second stream + let mut s2 = h2.request(request, false).unwrap(); - // Request capacity - s2.reserve_capacity(5); + // Request capacity + s2.reserve_capacity(5); - // There should be no available capacity (as it is being held up by - // the previous stream - assert_eq!(s2.capacity(), 0); + // There should be no available capacity (as it is being held up by + // the previous stream + assert_eq!(s2.capacity(), 0); - // Closing the previous stream by sending an empty data frame will - // release the capacity to s2 - s1.send_data("".into(), true).unwrap(); + // Closing the previous stream by sending an empty data frame will + // release the capacity to s2 + s1.send_data("".into(), true).unwrap(); - // The capacity should be available - assert_eq!(s2.capacity(), 5); + // The capacity should be available + assert_eq!(s2.capacity(), 5); - // Send the frame - s2.send_data("hello".into(), true).unwrap(); + // Send the frame + s2.send_data("hello".into(), true).unwrap(); - // Wait for the connection to close - h2.unwrap() - }) - ; + // Wait for the connection to close + h2.unwrap() + }); let mock = mock.assert_client_handshake().unwrap() // Get the first frame @@ -357,11 +352,9 @@ fn stream_close_by_data_frame_releases_capacity() { assert!(data.is_end_stream()); Ok(()) - }) - ; + }); - let _ = h2.join(mock) - .wait().unwrap(); + let _ = h2.join(mock).wait().unwrap(); } #[test] @@ -371,52 +364,52 @@ fn stream_close_by_trailers_frame_releases_capacity() { let window_size = frame::DEFAULT_INITIAL_WINDOW_SIZE as usize; - let h2 = Client::handshake(m).unwrap() - .and_then(|mut h2| { - let request = Request::builder() - .method(Method::POST) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let h2 = Client::handshake(m).unwrap().and_then(|mut h2| { + let request = Request::builder() + .method(Method::POST) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - // Send request - let mut s1 = h2.request(request, false).unwrap(); + // Send request + let mut s1 = h2.request(request, false).unwrap(); - // This effectively reserves the entire connection window - s1.reserve_capacity(window_size); + // This effectively reserves the entire connection window + s1.reserve_capacity(window_size); - // The capacity should be immediately available as nothing else is - // happening on the stream. - assert_eq!(s1.capacity(), window_size); + // The capacity should be immediately available as nothing else is + // happening on the stream. + assert_eq!(s1.capacity(), window_size); - let request = Request::builder() - .method(Method::POST) - .uri("https://http2.akamai.com/") - .body(()).unwrap(); + let request = Request::builder() + .method(Method::POST) + .uri("https://http2.akamai.com/") + .body(()) + .unwrap(); - // Create a second stream - let mut s2 = h2.request(request, false).unwrap(); + // Create a second stream + let mut s2 = h2.request(request, false).unwrap(); - // Request capacity - s2.reserve_capacity(5); + // Request capacity + s2.reserve_capacity(5); - // There should be no available capacity (as it is being held up by - // the previous stream - assert_eq!(s2.capacity(), 0); + // There should be no available capacity (as it is being held up by + // the previous stream + assert_eq!(s2.capacity(), 0); - // Closing the previous stream by sending a trailers frame will - // release the capacity to s2 - s1.send_trailers(Default::default()).unwrap(); + // Closing the previous stream by sending a trailers frame will + // release the capacity to s2 + s1.send_trailers(Default::default()).unwrap(); - // The capacity should be available - assert_eq!(s2.capacity(), 5); + // The capacity should be available + assert_eq!(s2.capacity(), 5); - // Send the frame - s2.send_data("hello".into(), true).unwrap(); + // Send the frame + s2.send_data("hello".into(), true).unwrap(); - // Wait for the connection to close - h2.unwrap() - }) - ; + // Wait for the connection to close + h2.unwrap() + }); let mock = mock.assert_client_handshake().unwrap() // Get the first frame @@ -453,22 +446,18 @@ fn stream_close_by_trailers_frame_releases_capacity() { assert!(data.is_end_stream()); Ok(()) - }) - ; + }); - let _ = h2.join(mock) - .wait().unwrap(); + let _ = h2.join(mock).wait().unwrap(); } #[test] #[ignore] -fn stream_close_by_send_reset_frame_releases_capacity() { -} +fn stream_close_by_send_reset_frame_releases_capacity() {} #[test] #[ignore] -fn stream_close_by_recv_reset_frame_releases_capacity() { -} +fn stream_close_by_recv_reset_frame_releases_capacity() {} use futures::{Async, Poll}; @@ -496,19 +485,21 @@ fn recv_window_update_on_stream_closed_by_data_frame() { let _ = ::env_logger::init(); let (io, srv) = mock::new(); - let h2 = Client::handshake(io).unwrap() + let h2 = Client::handshake(io) + .unwrap() .and_then(|mut h2| { let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let stream = h2.request(request, false).unwrap(); // Wait for the response h2.drive(GetResponse { - stream: Some(stream), - }) + stream: Some(stream), + }) }) .and_then(|(h2, (response, mut stream))| { assert_eq!(response.status(), StatusCode::OK); @@ -518,26 +509,18 @@ fn recv_window_update_on_stream_closed_by_data_frame() { // Wait for the connection to close h2.unwrap() - }) - ; + }); - let srv = srv.assert_client_handshake().unwrap() + let srv = srv.assert_client_handshake() + .unwrap() .recv_settings() - .recv_frame( - frames::headers(1) - .request("POST", "https://http2.akamai.com/") - ) - .send_frame( - frames::headers(1) - .response(200) - ) + .recv_frame(frames::headers(1).request("POST", "https://http2.akamai.com/")) + .send_frame(frames::headers(1).response(200)) .recv_frame(frames::data(1, "hello").eos()) .send_frame(frames::window_update(1, 5)) - .map(drop) - ; + .map(drop); - let _ = h2.join(srv) - .wait().unwrap(); + let _ = h2.join(srv).wait().unwrap(); } #[test] @@ -545,12 +528,14 @@ fn reserved_capacity_assigned_in_multi_window_updates() { let _ = ::env_logger::init(); let (io, srv) = mock::new(); - let h2 = Client::handshake(io).unwrap() + let h2 = Client::handshake(io) + .unwrap() .and_then(|mut h2| { let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let mut stream = h2.request(request, false).unwrap(); @@ -567,15 +552,16 @@ fn reserved_capacity_assigned_in_multi_window_updates() { stream.send_data("hello".into(), false).unwrap(); stream.send_data("world".into(), true).unwrap(); - h2.drive(GetResponse { stream: Some(stream) }) + h2.drive(GetResponse { + stream: Some(stream), + }) }) .and_then(|(h2, (response, _))| { assert_eq!(response.status(), StatusCode::NO_CONTENT); // Wait for the connection to close h2.unwrap() - }) - ; + }); let srv = srv.assert_client_handshake().unwrap() .recv_settings() @@ -613,9 +599,7 @@ fn reserved_capacity_assigned_in_multi_window_updates() { .recv_frame(frames::data(1, "hello").eos()) .send_frame(frames::window_update(1, 5)) */ - .map(drop) - ; + .map(drop); - let _ = h2.join(srv) - .wait().unwrap(); + let _ = h2.join(srv).wait().unwrap(); } diff --git a/tests/ping_pong.rs b/tests/ping_pong.rs index 25d39e1..f15dd17 100644 --- a/tests/ping_pong.rs +++ b/tests/ping_pong.rs @@ -8,10 +8,10 @@ fn recv_single_ping() { let (m, mock) = mock::new(); // Create the handshake - let h2 = Client::handshake(m).unwrap() - .and_then(|conn| conn.unwrap()); + let h2 = Client::handshake(m).unwrap().and_then(|conn| conn.unwrap()); - let mock = mock.assert_client_handshake().unwrap() + let mock = mock.assert_client_handshake() + .unwrap() .and_then(|(_, mut mock)| { let frame = frame::Ping::new(); mock.send(frame.into()).unwrap(); @@ -30,6 +30,5 @@ fn recv_single_ping() { Ok(()) }); - let _ = h2.join(mock) - .wait().unwrap(); + let _ = h2.join(mock).wait().unwrap(); } diff --git a/tests/prioritization.rs b/tests/prioritization.rs index add69ed..edba3b4 100644 --- a/tests/prioritization.rs +++ b/tests/prioritization.rs @@ -25,13 +25,13 @@ fn single_stream_send_large_body() { .read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let mut stream = h2.request(request, false).unwrap(); @@ -79,13 +79,13 @@ fn single_stream_send_extra_large_body_multi_frames_one_buffer() { .read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let mut stream = h2.request(request, false).unwrap(); @@ -144,13 +144,13 @@ fn single_stream_send_extra_large_body_multi_frames_multi_buffer() { .read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); let mut stream = h2.request(request, false).unwrap(); @@ -175,12 +175,14 @@ fn send_data_receive_window_update() { let _ = ::env_logger::init(); let (m, mock) = mock::new(); - let h2 = Client::handshake(m).unwrap() + let h2 = Client::handshake(m) + .unwrap() .and_then(|mut h2| { let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); // Send request let mut stream = h2.request(request, false).unwrap(); @@ -240,9 +242,7 @@ fn send_data_receive_window_update() { let data = assert_data!(frame.unwrap()); assert_eq!(data.payload().len(), (frame::DEFAULT_MAX_FRAME_SIZE-1) as usize); Ok(()) - }) - ; + }); - let _ = h2.join(mock) - .wait().unwrap(); + let _ = h2.join(mock).wait().unwrap(); } diff --git a/tests/server.rs b/tests/server.rs index 16388d8..ce2c9e2 100644 --- a/tests/server.rs +++ b/tests/server.rs @@ -17,13 +17,11 @@ fn read_preface_in_multiple_frames() { .read(SETTINGS_ACK) .build(); - let h2 = Server::handshake(mock) - .wait().unwrap(); + let h2 = Server::handshake(mock).wait().unwrap(); assert!(Stream::wait(h2).next().is_none()); } #[test] #[ignore] -fn accept_with_pending_connections_after_socket_close() { -} +fn accept_with_pending_connections_after_socket_close() {} diff --git a/tests/stream_states.rs b/tests/stream_states.rs index 6e7cb7e..1c120ff 100644 --- a/tests/stream_states.rs +++ b/tests/stream_states.rs @@ -20,13 +20,13 @@ fn send_recv_headers_only() { .read(&[0, 0, 1, 1, 5, 0, 0, 0, 1, 0x89]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); // Send the request let request = Request::builder() .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let mut stream = h2.request(request, true).unwrap(); @@ -62,13 +62,13 @@ fn send_recv_data() { ]) .build(); - let mut h2 = Client::handshake2(mock) - .wait().unwrap(); + let mut h2 = Client::handshake2(mock).wait().unwrap(); let request = Request::builder() .method(Method::POST) .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let mut stream = h2.request(request, false).unwrap(); @@ -119,13 +119,13 @@ fn send_headers_recv_data_single_frame() { ]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); // Send the request let request = Request::builder() .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let mut stream = h2.request(request, true).unwrap(); @@ -154,10 +154,10 @@ fn closed_streams_are_released() { let _ = ::env_logger::init(); let (io, srv) = mock::new(); - let h2 = Client::handshake(io).unwrap() + let h2 = Client::handshake(io) + .unwrap() .and_then(|mut h2| { - let request = Request::get("https://example.com/") - .body(()).unwrap(); + let request = Request::get("https://example.com/").body(()).unwrap(); // Send request let stream = h2.request(request, true).unwrap(); @@ -179,26 +179,18 @@ fn closed_streams_are_released() { assert_eq!(0, h2.num_wired_streams()); Ok(()) - }) - ; + }); - let srv = srv.assert_client_handshake().unwrap() + let srv = srv.assert_client_handshake() + .unwrap() .recv_settings() - .recv_frame( - frames::headers(1) - .request("GET", "https://example.com/") - .eos() - ) - .send_frame( - frames::headers(1) - .response(204) - .eos() - ) - .close() - ; + .recv_frame(frames::headers(1) + .request("GET", "https://example.com/") + .eos()) + .send_frame(frames::headers(1).response(204).eos()) + .close(); - let _ = h2.join(srv) - .wait().unwrap(); + let _ = h2.join(srv).wait().unwrap(); } /* diff --git a/tests/trailers.rs b/tests/trailers.rs index a365ddb..119c547 100644 --- a/tests/trailers.rs +++ b/tests/trailers.rs @@ -23,13 +23,13 @@ fn recv_trailers_only() { ]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); // Send the request let request = Request::builder() .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let mut stream = h2.request(request, true).unwrap(); @@ -71,13 +71,13 @@ fn send_trailers_immediately() { ]) .build(); - let mut h2 = Client::handshake(mock) - .wait().unwrap(); + let mut h2 = Client::handshake(mock).wait().unwrap(); // Send the request let request = Request::builder() .uri("https://http2.akamai.com/") - .body(()).unwrap(); + .body(()) + .unwrap(); info!("sending request"); let mut stream = h2.request(request, false).unwrap();