forked/h2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Much work

Browse Source
This commit is contained in:
Carl Lerche
2017-06-23 13:13:50 -07:00
parent a3950354aa
commit fa21970656
15 changed files with 531 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
src/proto/connection.rs
View File

@@ -1,11 +1,24 @@
use {frame, proto, ConnectionError};
use {frame, Frame, ConnectionError, Peer, StreamId};
use proto::{self, ReadySink, State};
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::codec::length_delimited;
use http;
use futures::*;
pub struct Connection<T> {
use ordermap::OrderMap;
use fnv::FnvHasher;
use std::marker::PhantomData;
use std::hash::BuildHasherDefault;
/// An H2 connection
pub struct Connection<T, P> {
inner: Inner<T>,
streams: StreamMap<State>,
peer: PhantomData<P>,
}
type Inner<T> =
@@ -15,72 +28,154 @@ type Inner<T> =
proto::FramedRead<
length_delimited::FramedRead<T>>>>>;
impl<T: AsyncRead + AsyncWrite> Connection<T> {
pub fn new(io: T) -> Connection<T> {
// Delimit the frames
let framed_read = length_delimited::Builder::new()
.big_endian()
.length_field_length(3)
.length_adjustment(6)
.num_skip(0) // Don't skip the header
.new_read(io);
type StreamMap<T> = OrderMap<StreamId, T, BuildHasherDefault<FnvHasher>>;
// Map to `Frame` types
let framed_read = proto::FramedRead::new(framed_read);
/// Returns a new `Connection` backed by the given `io`.
pub fn new<T, P>(io: T) -> Connection<T, P>
where T: AsyncRead + AsyncWrite,
P: Peer,
{
// Frame encoder
let mut framed = proto::FramedWrite::new(framed_read);
// Delimit the frames
let framed_read = length_delimited::Builder::new()
.big_endian()
.length_field_length(3)
.length_adjustment(9)
.num_skip(0) // Don't skip the header
.new_read(io);
// Ok, so this is a **little** hacky, but it works for now.
//
// The ping/pong behavior SHOULD be given highest priority (6.7).
// However, the connection handshake requires the settings frame to be
// sent as the very first one. This needs special handling because
// otherwise there is a race condition where the peer could send its
// settings frame followed immediately by a Ping, in which case, we
// don't want to accidentally send the pong before finishing the
// connection hand shake.
//
// So, to ensure correct ordering, we write the settings frame here
// before fully constructing the connection struct. Technically, `Async`
// operations should not be performed in `new` because this might not
// happen on a task, however we have full control of the I/O and we know
// that the settings frame will get buffered and not actually perform an
// I/O op.
let initial_settings = frame::SettingSet::default();
let frame = frame::Settings::new(initial_settings.clone());
assert!(framed.start_send(frame.into()).unwrap().is_ready());
// Map to `Frame` types
let framed_read = proto::FramedRead::new(framed_read);
// Add ping/pong handler
let ping_pong = proto::PingPong::new(framed);
// Frame encoder
let mut framed = proto::FramedWrite::new(framed_read);
// Add settings handler
let connection = proto::Settings::new(ping_pong, initial_settings);
// Ok, so this is a **little** hacky, but it works for now.
//
// The ping/pong behavior SHOULD be given highest priority (6.7).
// However, the connection handshake requires the settings frame to be
// sent as the very first one. This needs special handling because
// otherwise there is a race condition where the peer could send its
// settings frame followed immediately by a Ping, in which case, we
// don't want to accidentally send the pong before finishing the
// connection hand shake.
//
// So, to ensure correct ordering, we write the settings frame here
// before fully constructing the connection struct. Technically, `Async`
// operations should not be performed in `new` because this might not
// happen on a task, however we have full control of the I/O and we know
// that the settings frame will get buffered and not actually perform an
// I/O op.
let initial_settings = frame::SettingSet::default();
let frame = frame::Settings::new(initial_settings.clone());
assert!(framed.start_send(frame.into()).unwrap().is_ready());
Connection {
inner: connection,
// Add ping/pong handler
let ping_pong = proto::PingPong::new(framed);
// Add settings handler
let connection = proto::Settings::new(ping_pong, initial_settings);
Connection {
inner: connection,
streams: StreamMap::default(),
peer: PhantomData,
}
}
impl<T, P> Connection<T, P>
where T: AsyncRead + AsyncWrite,
P: Peer,
{
/// Completes when the connection has terminated
pub fn poll_shutdown(&mut self) -> Poll<(), ConnectionError> {
try_ready!(self.poll_complete());
Ok(Async::NotReady)
}
}
impl<T, P> Stream for Connection<T, P>
where T: AsyncRead + AsyncWrite,
P: Peer,
{
type Item = Frame<P::Poll>;
type Error = ConnectionError;
fn poll(&mut self) -> Poll<Option<Self::Item>, ConnectionError> {
use frame::Frame::*;
match try_ready!(self.inner.poll()) {
Some(Headers(v)) => unimplemented!(),
Some(frame) => panic!("unexpected frame; frame={:?}", frame),
None => return Ok(Async::Ready(None)),
_ => unimplemented!(),
}
}
}
impl<T: AsyncRead + AsyncWrite> Stream for Connection<T> {
type Item = frame::Frame;
type Error = ConnectionError;
fn poll(&mut self) -> Poll<Option<frame::Frame>, ConnectionError> {
self.inner.poll()
}
}
impl<T: AsyncRead + AsyncWrite> Sink for Connection<T> {
type SinkItem = frame::Frame;
impl<T, P> Sink for Connection<T, P>
where T: AsyncRead + AsyncWrite,
P: Peer,
{
type SinkItem = Frame<P::Send>;
type SinkError = ConnectionError;
fn start_send(&mut self, item: frame::Frame) -> StartSend<frame::Frame, ConnectionError> {
self.inner.start_send(item)
fn start_send(&mut self, item: Self::SinkItem)
-> StartSend<Self::SinkItem, Self::SinkError>
{
// First ensure that the upstream can process a new item
if !try!(self.poll_ready()).is_ready() {
return Ok(AsyncSink::NotReady(item));
}
match item {
Frame::Message { id, message, body } => {
// Ensure ID is valid
try!(P::check_initiating_id(id));
// TODO: Ensure available capacity for a new stream
// This won't be as simple as self.streams.len() as closed
// connections should not be factored.
// Transition the stream state, creating a new entry if needed
try!(self.streams.entry(id)
.or_insert(State::default())
.send_headers());
let message = P::convert_send_message(id, message, body);
// TODO: Handle trailers and all that jazz
// We already ensured that the upstream can handle the frame, so
// panic if it gets rejected.
let res = try!(self.inner.start_send(frame::Frame::Headers(message.frame)));
// This is a one-way conversion. By checking `poll_ready` first,
// it's already been determined that the inner `Sink` can accept
// the item. If the item is rejected, then there is a bug.
assert!(res.is_ready());
Ok(AsyncSink::Ready)
}
Frame::Body { id, chunk } => {
unimplemented!();
}
Frame::Error { id, error } => {
unimplemented!();
}
}
}
fn poll_complete(&mut self) -> Poll<(), ConnectionError> {
self.inner.poll_complete()
}
}
impl<T, P> ReadySink for Connection<T, P>
where T: AsyncRead + AsyncWrite,
P: Peer,
{
fn poll_ready(&mut self) -> Poll<(), Self::SinkError> {
self.inner.poll_ready()
}
}