actix/actix-web
1
0
Fork 0
mirror of https://github.com/fafhrd91/actix-web synced 2024-11-27 17:52:56 +01:00
Code Issues Releases Wiki Activity

refactor TransferEncoding; allow to use client api with threaded tokio runtime

Browse Source
This commit is contained in:
Nikolay Kim 2018-05-29 16:32:39 -07:00
parent 844be8d9dd
commit a64205e502
18 changed files with 344 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/body.rs
View File

@ -1,6 +1,5 @@
use bytes::{Bytes, BytesMut};
use futures::Stream;
use std::rc::Rc;
use std::sync::Arc;
use std::{fmt, mem};
@ -35,10 +34,8 @@ pub enum Binary {
/// Static slice
Slice(&'static [u8]),
/// Shared string body
SharedString(Rc<String>),
/// Shared string body
#[doc(hidden)]
ArcSharedString(Arc<String>),
SharedString(Arc<String>),
/// Shared vec body
SharedVec(Arc<Vec<u8>>),
}
@ -140,7 +137,6 @@ impl Binary {
Binary::Bytes(ref bytes) => bytes.len(),
Binary::Slice(slice) => slice.len(),
Binary::SharedString(ref s) => s.len(),
Binary::ArcSharedString(ref s) => s.len(),
Binary::SharedVec(ref s) => s.len(),
}
}
@ -162,7 +158,6 @@ impl Clone for Binary {
Binary::Bytes(ref bytes) => Binary::Bytes(bytes.clone()),
Binary::Slice(slice) => Binary::Bytes(Bytes::from(slice)),
Binary::SharedString(ref s) => Binary::SharedString(s.clone()),
Binary::ArcSharedString(ref s) => Binary::ArcSharedString(s.clone()),
Binary::SharedVec(ref s) => Binary::SharedVec(s.clone()),
}
}
@ -174,7 +169,6 @@ impl Into<Bytes> for Binary {
Binary::Bytes(bytes) => bytes,
Binary::Slice(slice) => Bytes::from(slice),
Binary::SharedString(s) => Bytes::from(s.as_str()),
Binary::ArcSharedString(s) => Bytes::from(s.as_str()),
Binary::SharedVec(s) => Bytes::from(AsRef::<[u8]>::as_ref(s.as_ref())),
}
}
@ -222,27 +216,15 @@ impl From<BytesMut> for Binary {
}
}
impl From<Rc<String>> for Binary {
fn from(body: Rc<String>) -> Binary {
Binary::SharedString(body)
}
}
impl<'a> From<&'a Rc<String>> for Binary {
fn from(body: &'a Rc<String>) -> Binary {
Binary::SharedString(Rc::clone(body))
}
}
impl From<Arc<String>> for Binary {
fn from(body: Arc<String>) -> Binary {
Binary::ArcSharedString(body)
Binary::SharedString(body)
}
}
impl<'a> From<&'a Arc<String>> for Binary {
fn from(body: &'a Arc<String>) -> Binary {
Binary::ArcSharedString(Arc::clone(body))
Binary::SharedString(Arc::clone(body))
}
}
@ -265,7 +247,6 @@ impl AsRef<[u8]> for Binary {
Binary::Bytes(ref bytes) => bytes.as_ref(),
Binary::Slice(slice) => slice,
Binary::SharedString(ref s) => s.as_bytes(),
Binary::ArcSharedString(ref s) => s.as_bytes(),
Binary::SharedVec(ref s) => s.as_ref().as_ref(),
}
}
@ -324,22 +305,6 @@ mod tests {
assert_eq!(Binary::from(Bytes::from("test")).as_ref(), b"test");
}
#[test]
fn test_ref_string() {
let b = Rc::new("test".to_owned());
assert_eq!(Binary::from(&b).len(), 4);
assert_eq!(Binary::from(&b).as_ref(), b"test");
}
#[test]
fn test_rc_string() {
let b = Rc::new("test".to_owned());
assert_eq!(Binary::from(b.clone()).len(), 4);
assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
assert_eq!(Binary::from(&b).len(), 4);
assert_eq!(Binary::from(&b).as_ref(), b"test");
}
#[test]
fn test_arc_string() {
let b = Arc::new("test".to_owned());

94
src/client/body.rs Normal file
View File

@ -0,0 +1,94 @@
use std::fmt;
use bytes::Bytes;
use futures::Stream;
use body::Binary;
use context::ActorHttpContext;
use error::Error;
/// Type represent streaming body
pub type ClientBodyStream = Box<Stream<Item = Bytes, Error = Error> + Send>;
/// Represents various types of http message body.
pub enum ClientBody {
/// Empty response. `Content-Length` header is set to `0`
Empty,
/// Specific response body.
Binary(Binary),
/// Unspecified streaming response. Developer is responsible for setting
/// right `Content-Length` or `Transfer-Encoding` headers.
Streaming(ClientBodyStream),
/// Special body type for actor response.
Actor(Box<ActorHttpContext + Send>),
}
impl ClientBody {
/// Does this body streaming.
#[inline]
pub fn is_streaming(&self) -> bool {
match *self {
ClientBody::Streaming(_) | ClientBody::Actor(_) => true,
_ => false,
}
}
/// Is this binary body.
#[inline]
pub fn is_binary(&self) -> bool {
match *self {
ClientBody::Binary(_) => true,
_ => false,
}
}
/// Is this binary empy.
#[inline]
pub fn is_empty(&self) -> bool {
match *self {
ClientBody::Empty => true,
_ => false,
}
}
/// Create body from slice (copy)
pub fn from_slice(s: &[u8]) -> ClientBody {
ClientBody::Binary(Binary::Bytes(Bytes::from(s)))
}
}
impl PartialEq for ClientBody {
fn eq(&self, other: &ClientBody) -> bool {
match *self {
ClientBody::Empty => match *other {
ClientBody::Empty => true,
_ => false,
},
ClientBody::Binary(ref b) => match *other {
ClientBody::Binary(ref b2) => b == b2,
_ => false,
},
ClientBody::Streaming(_) | ClientBody::Actor(_) => false,
}
}
}
impl fmt::Debug for ClientBody {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ClientBody::Empty => write!(f, "ClientBody::Empty"),
ClientBody::Binary(ref b) => write!(f, "ClientBody::Binary({:?})", b),
ClientBody::Streaming(_) => write!(f, "ClientBody::Streaming(_)"),
ClientBody::Actor(_) => write!(f, "ClientBody::Actor(_)"),
}
}
}
impl<T> From<T> for ClientBody
where
T: Into<Binary>,
{
fn from(b: T) -> ClientBody {
ClientBody::Binary(b.into())
}
}

16
src/client/mod.rs
View File

@ -1,11 +1,12 @@
//! Http client api
//!
//! ```rust,ignore
//! ```rust
//! # extern crate actix;
//! # extern crate actix_web;
//! # extern crate futures;
//! # extern crate tokio;
//! # use futures::Future;
//! # use std::process;
//! use actix_web::client;
//!
//! fn main() {
@ -17,11 +18,14 @@
//! .map_err(|_| ())
//! .and_then(|response| { // <- server http response
//! println!("Response: {:?}", response);
//! # process::exit(0);
//! Ok(())
//! })
//! });
//! }
//! ```
mod body;
mod connector;
mod parser;
mod pipeline;
@ -29,6 +33,7 @@ mod request;
mod response;
mod writer;
pub use self::body::{ClientBody, ClientBodyStream};
pub use self::connector::{
ClientConnector, ClientConnectorError, ClientConnectorStats, Connect, Connection,
Pause, Resume,
@ -56,11 +61,15 @@ impl ResponseError for SendRequestError {
/// Create request builder for `GET` requests
///
/// ```rust,ignore
///
/// ```rust
/// # extern crate actix;
/// # extern crate actix_web;
/// # extern crate futures;
/// # use futures::{future, Future};
/// # extern crate tokio;
/// # extern crate env_logger;
/// # use futures::Future;
/// # use std::process;
/// use actix_web::client;
///
/// fn main() {
@ -72,6 +81,7 @@ impl ResponseError for SendRequestError {
/// .map_err(|_| ())
/// .and_then(|response| { // <- server http response
/// println!("Response: {:?}", response);
/// # process::exit(0);
/// Ok(())
/// }));
/// }

110
src/client/pipeline.rs
View File

@ -1,5 +1,5 @@
use bytes::{Bytes, BytesMut};
use futures::unsync::oneshot;
use futures::sync::oneshot;
use futures::{Async, Future, Poll};
use http::header::CONTENT_ENCODING;
use std::time::{Duration, Instant};
@ -8,18 +8,16 @@ use tokio_timer::Delay;
use actix::prelude::*;
use super::HttpClientWriter;
use super::{ClientConnector, ClientConnectorError, Connect, Connection};
use super::{ClientRequest, ClientResponse};
use super::{HttpResponseParser, HttpResponseParserError};
use body::{Body, BodyStream};
use context::{ActorHttpContext, Frame};
use super::{
ClientBody, ClientBodyStream, ClientConnector, ClientConnectorError, ClientRequest,
ClientResponse, Connect, Connection, HttpClientWriter, HttpResponseParser,
HttpResponseParserError,
};
use error::Error;
use error::PayloadError;
use header::ContentEncoding;
use httpmessage::HttpMessage;
use server::encoding::PayloadStream;
use server::shared::SharedBytes;
use server::WriterState;
/// A set of errors that can occur during request sending and response reading
@ -68,7 +66,7 @@ enum State {
pub struct SendRequest {
req: ClientRequest,
state: State,
conn: Addr<ClientConnector>,
conn: Option<Addr<ClientConnector>>,
conn_timeout: Duration,
wait_timeout: Duration,
timeout: Option<Delay>,
@ -76,7 +74,14 @@ pub struct SendRequest {
impl SendRequest {
pub(crate) fn new(req: ClientRequest) -> SendRequest {
SendRequest::with_connector(req, ClientConnector::from_registry())
SendRequest {
req,
conn: None,
state: State::New,
timeout: None,
wait_timeout: Duration::from_secs(5),
conn_timeout: Duration::from_secs(1),
}
}
pub(crate) fn with_connector(
@ -84,7 +89,7 @@ impl SendRequest {
) -> SendRequest {
SendRequest {
req,
conn,
conn: Some(conn),
state: State::New,
timeout: None,
wait_timeout: Duration::from_secs(5),
@ -96,7 +101,7 @@ impl SendRequest {
SendRequest {
req,
state: State::Connection(conn),
conn: ClientConnector::from_registry(),
conn: None,
timeout: None,
wait_timeout: Duration::from_secs(5),
conn_timeout: Duration::from_secs(1),
@ -142,7 +147,12 @@ impl Future for SendRequest {
match state {
State::New => {
self.state = State::Connect(self.conn.send(Connect {
let conn = if let Some(conn) = self.conn.take() {
conn
} else {
ClientConnector::from_registry()
};
self.state = State::Connect(conn.send(Connect {
uri: self.req.uri().clone(),
wait_timeout: self.wait_timeout,
conn_timeout: self.conn_timeout,
@ -160,16 +170,16 @@ impl Future for SendRequest {
Err(_) => {
return Err(SendRequestError::Connector(
ClientConnectorError::Disconnected,
))
));
}
},
State::Connection(conn) => {
let mut writer = HttpClientWriter::new(SharedBytes::default());
let mut writer = HttpClientWriter::new();
writer.start(&mut self.req)?;
let body = match self.req.replace_body(Body::Empty) {
Body::Streaming(stream) => IoBody::Payload(stream),
Body::Actor(ctx) => IoBody::Actor(ctx),
let body = match self.req.replace_body(ClientBody::Empty) {
ClientBody::Streaming(stream) => IoBody::Payload(stream),
ClientBody::Actor(_) => panic!("Client actor is not supported"),
_ => IoBody::Done,
};
@ -208,7 +218,9 @@ impl Future for SendRequest {
self.state = State::Send(pl);
return Ok(Async::NotReady);
}
Err(err) => return Err(SendRequestError::ParseError(err)),
Err(err) => {
return Err(SendRequestError::ParseError(err));
}
}
}
State::None => unreachable!(),
@ -233,8 +245,7 @@ pub(crate) struct Pipeline {
}
enum IoBody {
Payload(BodyStream),
Actor(Box<ActorHttpContext>),
Payload(ClientBodyStream),
Done,
}
@ -380,10 +391,7 @@ impl Pipeline {
match self.timeout.as_mut().unwrap().poll() {
Ok(Async::Ready(())) => return Err(SendRequestError::Timeout),
Ok(Async::NotReady) => (),
Err(e) => {
println!("err: {:?}", e);
return Err(SendRequestError::Timeout);
}
Err(_) => return Err(SendRequestError::Timeout),
}
}
Ok(())
@ -397,66 +405,24 @@ impl Pipeline {
let mut done = false;
if self.drain.is_none() && self.write_state != RunningState::Paused {
'outter: loop {
loop {
let result = match mem::replace(&mut self.body, IoBody::Done) {
IoBody::Payload(mut body) => match body.poll()? {
IoBody::Payload(mut stream) => match stream.poll()? {
Async::Ready(None) => {
self.writer.write_eof()?;
self.body_completed = true;
break;
}
Async::Ready(Some(chunk)) => {
self.body = IoBody::Payload(body);
self.writer.write(chunk.into())?
self.body = IoBody::Payload(stream);
self.writer.write(chunk.as_ref())?
}
Async::NotReady => {
done = true;
self.body = IoBody::Payload(body);
self.body = IoBody::Payload(stream);
break;
}
},
IoBody::Actor(mut ctx) => {
if self.disconnected {
ctx.disconnected();
}
match ctx.poll()? {
Async::Ready(Some(vec)) => {
if vec.is_empty() {
self.body = IoBody::Actor(ctx);
break;
}
let mut res = None;
for frame in vec {
match frame {
Frame::Chunk(None) => {
self.body_completed = true;
self.writer.write_eof()?;
break 'outter;
}
Frame::Chunk(Some(chunk)) => {
res = Some(self.writer.write(chunk)?)
}
Frame::Drain(fut) => self.drain = Some(fut),
}
}
self.body = IoBody::Actor(ctx);
if self.drain.is_some() {
self.write_state.resume();
break;
}
res.unwrap()
}
Async::Ready(None) => {
done = true;
break;
}
Async::NotReady => {
done = true;
self.body = IoBody::Actor(ctx);
break;
}
}
}
IoBody::Done => {
self.body_completed = true;
done = true;

29
src/client/request.rs
View File

@ -12,9 +12,9 @@ use serde::Serialize;
use serde_json;
use url::Url;
use super::body::ClientBody;
use super::connector::{ClientConnector, Connection};
use super::pipeline::SendRequest;
use body::Body;
use error::Error;
use header::{ContentEncoding, Header, IntoHeaderValue};
use http::header::{self, HeaderName, HeaderValue};
@ -24,11 +24,13 @@ use httprequest::HttpRequest;
/// An HTTP Client Request
///
/// ```rust,ignore
/// ```rust
/// # extern crate actix;
/// # extern crate actix_web;
/// # extern crate futures;
/// # extern crate tokio;
/// # use futures::Future;
/// # use std::process;
/// use actix_web::client::ClientRequest;
///
/// fn main() {
@ -40,6 +42,7 @@ use httprequest::HttpRequest;
/// .map_err(|_| ())
/// .and_then(|response| { // <- server http response
/// println!("Response: {:?}", response);
/// # process::exit(0);
/// Ok(())
/// })
/// );
@ -50,7 +53,7 @@ pub struct ClientRequest {
method: Method,
version: Version,
headers: HeaderMap,
body: Body,
body: ClientBody,
chunked: bool,
upgrade: bool,
timeout: Option<Duration>,
@ -73,7 +76,7 @@ impl Default for ClientRequest {
method: Method::default(),
version: Version::HTTP_11,
headers: HeaderMap::with_capacity(16),
body: Body::Empty,
body: ClientBody::Empty,
chunked: false,
upgrade: false,
timeout: None,
@ -217,17 +220,17 @@ impl ClientRequest {
/// Get body of this response
#[inline]
pub fn body(&self) -> &Body {
pub fn body(&self) -> &ClientBody {
&self.body
}
/// Set a body
pub fn set_body<B: Into<Body>>(&mut self, body: B) {
pub fn set_body<B: Into<ClientBody>>(&mut self, body: B) {
self.body = body.into();
}
/// Extract body, replace it with `Empty`
pub(crate) fn replace_body(&mut self, body: Body) -> Body {
pub(crate) fn replace_body(&mut self, body: ClientBody) -> ClientBody {
mem::replace(&mut self.body, body)
}
@ -578,7 +581,9 @@ impl ClientRequestBuilder {
/// Set a body and generate `ClientRequest`.
///
/// `ClientRequestBuilder` can not be used after this call.
pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<ClientRequest, Error> {
pub fn body<B: Into<ClientBody>>(
&mut self, body: B,
) -> Result<ClientRequest, Error> {
if let Some(e) = self.err.take() {
return Err(e.into());
}
@ -644,17 +649,19 @@ impl ClientRequestBuilder {
/// `ClientRequestBuilder` can not be used after this call.
pub fn streaming<S, E>(&mut self, stream: S) -> Result<ClientRequest, Error>
where
S: Stream<Item = Bytes, Error = E> + 'static,
S: Stream<Item = Bytes, Error = E> + Send + 'static,
E: Into<Error>,
{
self.body(Body::Streaming(Box::new(stream.map_err(|e| e.into()))))
self.body(ClientBody::Streaming(Box::new(
stream.map_err(|e| e.into()),
)))
}
/// Set an empty body and generate `ClientRequest`
///
/// `ClientRequestBuilder` can not be used after this call.
pub fn finish(&mut self) -> Result<ClientRequest, Error> {
self.body(Body::Empty)
self.body(ClientBody::Empty)
}
/// This method construct new `ClientRequestBuilder`

111
src/client/writer.rs
View File

@ -19,13 +19,12 @@ use http::{HttpTryFrom, Version};
use time::{self, Duration};
use tokio_io::AsyncWrite;
use body::{Binary, Body};
use body::Binary;
use header::ContentEncoding;
use server::encoding::{ContentEncoder, TransferEncoding};
use server::shared::SharedBytes;
use server::WriterState;
use client::ClientRequest;
use client::{ClientBody, ClientRequest};
const AVERAGE_HEADER_SIZE: usize = 30;
@ -42,20 +41,20 @@ pub(crate) struct HttpClientWriter {
flags: Flags,
written: u64,
headers_size: u32,
buffer: SharedBytes,
buffer: Box<BytesMut>,
buffer_capacity: usize,
encoder: ContentEncoder,
}
impl HttpClientWriter {
pub fn new(buffer: SharedBytes) -> HttpClientWriter {
let encoder = ContentEncoder::Identity(TransferEncoding::eof(buffer.clone()));
pub fn new() -> HttpClientWriter {
let encoder = ContentEncoder::Identity(TransferEncoding::eof());
HttpClientWriter {
flags: Flags::empty(),
written: 0,
headers_size: 0,
buffer_capacity: 0,
buffer,
buffer: Box::new(BytesMut::new()),
encoder,
}
}
@ -98,12 +97,23 @@ impl HttpClientWriter {
}
}
pub struct Writer<'a>(pub &'a mut BytesMut);
impl<'a> io::Write for Writer<'a> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl HttpClientWriter {
pub fn start(&mut self, msg: &mut ClientRequest) -> io::Result<()> {
// prepare task
self.flags.insert(Flags::STARTED);
self.encoder = content_encoder(self.buffer.clone(), msg);
self.encoder = content_encoder(self.buffer.as_mut(), msg);
if msg.upgrade() {
self.flags.insert(Flags::UPGRADE);
}
@ -112,7 +122,7 @@ impl HttpClientWriter {
{
// status line
writeln!(
self.buffer,
Writer(&mut self.buffer),
"{} {} {:?}\r",
msg.method(),
msg.uri()
@ -120,40 +130,41 @@ impl HttpClientWriter {
.map(|u| u.as_str())
.unwrap_or("/"),
msg.version()
)?;
).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
// write headers
let mut buffer = self.buffer.get_mut();
if let Body::Binary(ref bytes) = *msg.body() {
buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE + bytes.len());
if let ClientBody::Binary(ref bytes) = *msg.body() {
self.buffer
.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE + bytes.len());
} else {
buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE);
self.buffer
.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE);
}
for (key, value) in msg.headers() {
let v = value.as_ref();
let k = key.as_str().as_bytes();
buffer.reserve(k.len() + v.len() + 4);
buffer.put_slice(k);
buffer.put_slice(b": ");
buffer.put_slice(v);
buffer.put_slice(b"\r\n");
self.buffer.reserve(k.len() + v.len() + 4);
self.buffer.put_slice(k);
self.buffer.put_slice(b": ");
self.buffer.put_slice(v);
self.buffer.put_slice(b"\r\n");
}
// set date header
if !msg.headers().contains_key(DATE) {
buffer.extend_from_slice(b"date: ");
set_date(&mut buffer);
buffer.extend_from_slice(b"\r\n\r\n");
self.buffer.extend_from_slice(b"date: ");
set_date(&mut self.buffer);
self.buffer.extend_from_slice(b"\r\n\r\n");
} else {
buffer.extend_from_slice(b"\r\n");
self.buffer.extend_from_slice(b"\r\n");
}
self.headers_size = buffer.len() as u32;
self.headers_size = self.buffer.len() as u32;
if msg.body().is_binary() {
if let Body::Binary(bytes) = msg.replace_body(Body::Empty) {
if let ClientBody::Binary(bytes) = msg.replace_body(ClientBody::Empty) {
self.written += bytes.len() as u64;
self.encoder.write(bytes)?;
self.encoder.write(bytes.as_ref())?;
}
} else {
self.buffer_capacity = msg.write_buffer_capacity();
@ -162,7 +173,7 @@ impl HttpClientWriter {
Ok(())
}
pub fn write(&mut self, payload: Binary) -> io::Result<WriterState> {
pub fn write(&mut self, payload: &[u8]) -> io::Result<WriterState> {
self.written += payload.len() as u64;
if !self.flags.contains(Flags::DISCONNECTED) {
if self.flags.contains(Flags::UPGRADE) {
@ -210,20 +221,21 @@ impl HttpClientWriter {
}
}
fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder {
fn content_encoder(buf: &mut BytesMut, req: &mut ClientRequest) -> ContentEncoder {
let version = req.version();
let mut body = req.replace_body(Body::Empty);
let mut body = req.replace_body(ClientBody::Empty);
let mut encoding = req.content_encoding();
let transfer = match body {
Body::Empty => {
let mut transfer = match body {
ClientBody::Empty => {
req.headers_mut().remove(CONTENT_LENGTH);
TransferEncoding::length(0, buf)
TransferEncoding::length(0)
}
Body::Binary(ref mut bytes) => {
ClientBody::Binary(ref mut bytes) => {
if encoding.is_compression() {
let tmp = SharedBytes::default();
let transfer = TransferEncoding::eof(tmp.clone());
let mut tmp = BytesMut::new();
let mut transfer = TransferEncoding::eof();
transfer.set_buffer(&mut tmp);
let mut enc = match encoding {
#[cfg(feature = "flate2")]
ContentEncoding::Deflate => ContentEncoder::Deflate(
@ -242,7 +254,7 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
ContentEncoding::Auto => unreachable!(),
};
// TODO return error!
let _ = enc.write(bytes.clone());
let _ = enc.write(bytes.as_ref());
let _ = enc.write_eof();
*bytes = Binary::from(tmp.take());
@ -256,9 +268,9 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
let _ = write!(b, "{}", bytes.len());
req.headers_mut()
.insert(CONTENT_LENGTH, HeaderValue::try_from(b.freeze()).unwrap());
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
Body::Streaming(_) | Body::Actor(_) => {
ClientBody::Streaming(_) | ClientBody::Actor(_) => {
if req.upgrade() {
if version == Version::HTTP_2 {
error!("Connection upgrade is forbidden for HTTP/2");
@ -270,9 +282,9 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
encoding = ContentEncoding::Identity;
req.headers_mut().remove(CONTENT_ENCODING);
}
TransferEncoding::eof(buf)
TransferEncoding::eof()
} else {
streaming_encoding(buf, version, req)
streaming_encoding(version, req)
}
}
};
@ -283,6 +295,7 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
HeaderValue::from_static(encoding.as_str()),
);
}
transfer.set_buffer(buf);
req.replace_body(body);
match encoding {
@ -303,19 +316,17 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
}
}
fn streaming_encoding(
buf: SharedBytes, version: Version, req: &mut ClientRequest,
) -> TransferEncoding {
fn streaming_encoding(version: Version, req: &mut ClientRequest) -> TransferEncoding {
if req.chunked() {
// Enable transfer encoding
req.headers_mut().remove(CONTENT_LENGTH);
if version == Version::HTTP_2 {
req.headers_mut().remove(TRANSFER_ENCODING);
TransferEncoding::eof(buf)
TransferEncoding::eof()
} else {
req.headers_mut()
.insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
TransferEncoding::chunked(buf)
TransferEncoding::chunked()
}
} else {
// if Content-Length is specified, then use it as length hint
@ -338,9 +349,9 @@ fn streaming_encoding(
if !chunked {
if let Some(len) = len {
TransferEncoding::length(len, buf)
TransferEncoding::length(len)
} else {
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
} else {
// Enable transfer encoding
@ -348,11 +359,11 @@ fn streaming_encoding(
Version::HTTP_11 => {
req.headers_mut()
.insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
TransferEncoding::chunked(buf)
TransferEncoding::chunked()
}
_ => {
req.headers_mut().remove(TRANSFER_ENCODING);
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
}
}

2
src/context.rs
View File

@ -1,5 +1,5 @@
use futures::sync::oneshot;
use futures::sync::oneshot::Sender;
use futures::unsync::oneshot;
use futures::{Async, Future, Poll};
use smallvec::SmallVec;
use std::marker::PhantomData;

1
src/fs.rs
View File

@ -801,7 +801,6 @@ mod tests {
.finish()
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
// Invalid range header

2
src/pipeline.rs
View File

@ -3,7 +3,7 @@ use std::marker::PhantomData;
use std::rc::Rc;
use std::{io, mem};
use futures::unsync::oneshot;
use futures::sync::oneshot;
use futures::{Async, Future, Poll, Stream};
use log::Level::Debug;

157
src/server/encoding.rs
View File

@ -1,7 +1,7 @@
use std::fmt::Write as FmtWrite;
use std::io::{Read, Write};
use std::str::FromStr;
use std::{cmp, io, mem};
use std::{cmp, io, mem, ptr};
#[cfg(feature = "brotli")]
use brotli2::write::{BrotliDecoder, BrotliEncoder};
@ -25,8 +25,6 @@ use httprequest::HttpInnerMessage;
use httpresponse::HttpResponse;
use payload::{PayloadSender, PayloadStatus, PayloadWriter};
use super::shared::SharedBytes;
pub(crate) enum PayloadType {
Sender(PayloadSender),
Encoding(Box<EncodedPayload>),
@ -381,12 +379,12 @@ pub(crate) enum ContentEncoder {
}
impl ContentEncoder {
pub fn empty(bytes: SharedBytes) -> ContentEncoder {
ContentEncoder::Identity(TransferEncoding::eof(bytes))
pub fn empty() -> ContentEncoder {
ContentEncoder::Identity(TransferEncoding::eof())
}
pub fn for_server(
buf: SharedBytes, req: &HttpInnerMessage, resp: &mut HttpResponse,
buf: &mut BytesMut, req: &HttpInnerMessage, resp: &mut HttpResponse,
response_encoding: ContentEncoding,
) -> ContentEncoder {
let version = resp.version().unwrap_or_else(|| req.version);
@ -441,7 +439,7 @@ impl ContentEncoder {
if req.method != Method::HEAD {
resp.headers_mut().remove(CONTENT_LENGTH);
}
TransferEncoding::length(0, buf)
TransferEncoding::length(0)
}
&Body::Binary(_) => {
#[cfg(any(feature = "brotli", feature = "flate2"))]
@ -449,8 +447,9 @@ impl ContentEncoder {
if !(encoding == ContentEncoding::Identity
|| encoding == ContentEncoding::Auto)
{
let tmp = SharedBytes::default();
let transfer = TransferEncoding::eof(tmp.clone());
let mut tmp = BytesMut::default();
let mut transfer = TransferEncoding::eof();
transfer.set_buffer(&mut tmp);
let mut enc = match encoding {
#[cfg(feature = "flate2")]
ContentEncoding::Deflate => ContentEncoder::Deflate(
@ -472,7 +471,7 @@ impl ContentEncoder {
let bin = resp.replace_body(Body::Empty).binary();
// TODO return error!
let _ = enc.write(bin);
let _ = enc.write(bin.as_ref());
let _ = enc.write_eof();
let body = tmp.take();
len = body.len();
@ -492,7 +491,7 @@ impl ContentEncoder {
} else {
// resp.headers_mut().remove(CONTENT_LENGTH);
}
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
&Body::Streaming(_) | &Body::Actor(_) => {
if resp.upgrade() {
@ -503,14 +502,14 @@ impl ContentEncoder {
encoding = ContentEncoding::Identity;
resp.headers_mut().remove(CONTENT_ENCODING);
}
TransferEncoding::eof(buf)
TransferEncoding::eof()
} else {
if !(encoding == ContentEncoding::Identity
|| encoding == ContentEncoding::Auto)
{
resp.headers_mut().remove(CONTENT_LENGTH);
}
ContentEncoder::streaming_encoding(buf, version, resp)
ContentEncoder::streaming_encoding(version, resp)
}
}
};
@ -519,6 +518,7 @@ impl ContentEncoder {
resp.set_body(Body::Empty);
transfer.kind = TransferEncodingKind::Length(0);
}
transfer.set_buffer(buf);
match encoding {
#[cfg(feature = "flate2")]
@ -539,7 +539,7 @@ impl ContentEncoder {
}
fn streaming_encoding(
buf: SharedBytes, version: Version, resp: &mut HttpResponse,
version: Version, resp: &mut HttpResponse,
) -> TransferEncoding {
match resp.chunked() {
Some(true) => {
@ -547,14 +547,14 @@ impl ContentEncoder {
resp.headers_mut().remove(CONTENT_LENGTH);
if version == Version::HTTP_2 {
resp.headers_mut().remove(TRANSFER_ENCODING);
TransferEncoding::eof(buf)
TransferEncoding::eof()
} else {
resp.headers_mut()
.insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
TransferEncoding::chunked(buf)
TransferEncoding::chunked()
}
}
Some(false) => TransferEncoding::eof(buf),
Some(false) => TransferEncoding::eof(),
None => {
// if Content-Length is specified, then use it as length hint
let (len, chunked) =
@ -577,9 +577,9 @@ impl ContentEncoder {
if !chunked {
if let Some(len) = len {
TransferEncoding::length(len, buf)
TransferEncoding::length(len)
} else {
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
} else {
// Enable transfer encoding
@ -589,11 +589,11 @@ impl ContentEncoder {
TRANSFER_ENCODING,
HeaderValue::from_static("chunked"),
);
TransferEncoding::chunked(buf)
TransferEncoding::chunked()
}
_ => {
resp.headers_mut().remove(TRANSFER_ENCODING);
TransferEncoding::eof(buf)
TransferEncoding::eof()
}
}
}
@ -619,10 +619,8 @@ impl ContentEncoder {
#[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
#[inline(always)]
pub fn write_eof(&mut self) -> Result<bool, io::Error> {
let encoder = mem::replace(
self,
ContentEncoder::Identity(TransferEncoding::eof(SharedBytes::empty())),
);
let encoder =
mem::replace(self, ContentEncoder::Identity(TransferEncoding::eof()));
match encoder {
#[cfg(feature = "brotli")]
@ -662,38 +660,32 @@ impl ContentEncoder {
#[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
#[inline(always)]
pub fn write(&mut self, data: Binary) -> Result<(), io::Error> {
pub fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
match *self {
#[cfg(feature = "brotli")]
ContentEncoder::Br(ref mut encoder) => {
match encoder.write_all(data.as_ref()) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding br encoding: {}", err);
Err(err)
}
ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding br encoding: {}", err);
Err(err)
}
}
},
#[cfg(feature = "flate2")]
ContentEncoder::Gzip(ref mut encoder) => {
match encoder.write_all(data.as_ref()) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding gzip encoding: {}", err);
Err(err)
}
ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding gzip encoding: {}", err);
Err(err)
}
}
},
#[cfg(feature = "flate2")]
ContentEncoder::Deflate(ref mut encoder) => {
match encoder.write_all(data.as_ref()) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding deflate encoding: {}", err);
Err(err)
}
ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
Ok(_) => Ok(()),
Err(err) => {
trace!("Error decoding deflate encoding: {}", err);
Err(err)
}
}
},
ContentEncoder::Identity(ref mut encoder) => {
encoder.encode(data)?;
Ok(())
@ -705,10 +697,12 @@ impl ContentEncoder {
/// Encoders to handle different Transfer-Encodings.
#[derive(Debug, Clone)]
pub(crate) struct TransferEncoding {
buf: *mut BytesMut,
kind: TransferEncodingKind,
buffer: SharedBytes,
}
unsafe impl Send for TransferEncoding {}
#[derive(Debug, PartialEq, Clone)]
enum TransferEncodingKind {
/// An Encoder for when Transfer-Encoding includes `chunked`.
@ -724,27 +718,31 @@ enum TransferEncodingKind {
}
impl TransferEncoding {
pub(crate) fn set_buffer(&mut self, buf: *mut BytesMut) {
self.buf = buf;
}
#[inline]
pub fn eof(bytes: SharedBytes) -> TransferEncoding {
pub fn eof() -> TransferEncoding {
TransferEncoding {
kind: TransferEncodingKind::Eof,
buffer: bytes,
buf: ptr::null_mut(),
}
}
#[inline]
pub fn chunked(bytes: SharedBytes) -> TransferEncoding {
pub fn chunked() -> TransferEncoding {
TransferEncoding {
kind: TransferEncodingKind::Chunked(false),
buffer: bytes,
buf: ptr::null_mut(),
}
}
#[inline]
pub fn length(len: u64, bytes: SharedBytes) -> TransferEncoding {
pub fn length(len: u64) -> TransferEncoding {
TransferEncoding {
kind: TransferEncodingKind::Length(len),
buffer: bytes,
buf: ptr::null_mut(),
}
}
@ -759,11 +757,13 @@ impl TransferEncoding {
/// Encode message. Return `EOF` state of encoder
#[inline]
pub fn encode(&mut self, mut msg: Binary) -> io::Result<bool> {
pub fn encode(&mut self, msg: &[u8]) -> io::Result<bool> {
match self.kind {
TransferEncodingKind::Eof => {
let eof = msg.is_empty();
self.buffer.extend(msg);
debug_assert!(!self.buf.is_null());
let buf = unsafe { &mut *self.buf };
buf.extend(msg);
Ok(eof)
}
TransferEncodingKind::Chunked(ref mut eof) => {
@ -773,15 +773,20 @@ impl TransferEncoding {
if msg.is_empty() {
*eof = true;
self.buffer.extend_from_slice(b"0\r\n\r\n");
debug_assert!(!self.buf.is_null());
let buf = unsafe { &mut *self.buf };
buf.extend_from_slice(b"0\r\n\r\n");
} else {
let mut buf = BytesMut::new();
writeln!(&mut buf, "{:X}\r", msg.len())
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
self.buffer.reserve(buf.len() + msg.len() + 2);
self.buffer.extend(buf.into());
self.buffer.extend(msg);
self.buffer.extend_from_slice(b"\r\n");
debug_assert!(!self.buf.is_null());
let b = unsafe { &mut *self.buf };
b.reserve(buf.len() + msg.len() + 2);
b.extend_from_slice(buf.as_ref());
b.extend_from_slice(msg);
b.extend_from_slice(b"\r\n");
}
Ok(*eof)
}
@ -791,7 +796,9 @@ impl TransferEncoding {
return Ok(*remaining == 0);
}
let len = cmp::min(*remaining, msg.len() as u64);
self.buffer.extend(msg.take().split_to(len as usize).into());
debug_assert!(!self.buf.is_null());
unsafe { &mut *self.buf }.extend(&msg[..len as usize]);
*remaining -= len as u64;
Ok(*remaining == 0)
@ -811,7 +818,10 @@ impl TransferEncoding {
TransferEncodingKind::Chunked(ref mut eof) => {
if !*eof {
*eof = true;
self.buffer.extend_from_slice(b"0\r\n\r\n");
debug_assert!(!self.buf.is_null());
let buf = unsafe { &mut *self.buf };
buf.extend_from_slice(b"0\r\n\r\n");
}
true
}
@ -822,7 +832,7 @@ impl TransferEncoding {
impl io::Write for TransferEncoding {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.encode(Binary::from_slice(buf))?;
self.encode(buf)?;
Ok(buf.len())
}
@ -904,12 +914,15 @@ mod tests {
#[test]
fn test_chunked_te() {
let bytes = SharedBytes::default();
let mut enc = TransferEncoding::chunked(bytes.clone());
assert!(!enc.encode(Binary::from(b"test".as_ref())).ok().unwrap());
assert!(enc.encode(Binary::from(b"".as_ref())).ok().unwrap());
let mut bytes = BytesMut::new();
let mut enc = TransferEncoding::chunked();
{
enc.set_buffer(&mut bytes);
assert!(!enc.encode(b"test").ok().unwrap());
assert!(enc.encode(b"").ok().unwrap());
}
assert_eq!(
bytes.get_mut().take().freeze(),
bytes.take().freeze(),
Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
);
}

8
src/server/h1writer.rs
View File

@ -46,7 +46,7 @@ impl<T: AsyncWrite, H: 'static> H1Writer<T, H> {
) -> H1Writer<T, H> {
H1Writer {
flags: Flags::KEEPALIVE,
encoder: ContentEncoder::empty(buf.clone()),
encoder: ContentEncoder::empty(),
written: 0,
headers_size: 0,
buffer: buf,
@ -116,7 +116,7 @@ impl<T: AsyncWrite, H: 'static> Writer for H1Writer<T, H> {
) -> io::Result<WriterState> {
// prepare task
self.encoder =
ContentEncoder::for_server(self.buffer.clone(), req, msg, encoding);
ContentEncoder::for_server(self.buffer.get_mut(), req, msg, encoding);
if msg.keep_alive().unwrap_or_else(|| req.keep_alive()) {
self.flags = Flags::STARTED | Flags::KEEPALIVE;
} else {
@ -223,7 +223,7 @@ impl<T: AsyncWrite, H: 'static> Writer for H1Writer<T, H> {
if let Body::Binary(bytes) = body {
self.written = bytes.len() as u64;
self.encoder.write(bytes)?;
self.encoder.write(bytes.as_ref())?;
} else {
// capacity, makes sense only for streaming or actor
self.buffer_capacity = msg.write_buffer_capacity();
@ -251,7 +251,7 @@ impl<T: AsyncWrite, H: 'static> Writer for H1Writer<T, H> {
}
} else {
// TODO: add warning, write after EOF
self.encoder.write(payload)?;
self.encoder.write(payload.as_ref())?;
}
} else {
// could be response to EXCEPT header

8
src/server/h2writer.rs
View File

@ -51,7 +51,7 @@ impl<H: 'static> H2Writer<H> {
respond,
settings,
stream: None,
encoder: ContentEncoder::empty(buf.clone()),
encoder: ContentEncoder::empty(),
flags: Flags::empty(),
written: 0,
buffer: buf,
@ -88,7 +88,7 @@ impl<H: 'static> Writer for H2Writer<H> {
// prepare response
self.flags.insert(Flags::STARTED);
self.encoder =
ContentEncoder::for_server(self.buffer.clone(), req, msg, encoding);
ContentEncoder::for_server(self.buffer.get_mut(), req, msg, encoding);
if let Body::Empty = *msg.body() {
self.flags.insert(Flags::EOF);
}
@ -143,7 +143,7 @@ impl<H: 'static> Writer for H2Writer<H> {
if let Body::Binary(bytes) = body {
self.flags.insert(Flags::EOF);
self.written = bytes.len() as u64;
self.encoder.write(bytes)?;
self.encoder.write(bytes.as_ref())?;
if let Some(ref mut stream) = self.stream {
self.flags.insert(Flags::RESERVED);
stream.reserve_capacity(cmp::min(self.buffer.len(), CHUNK_SIZE));
@ -162,7 +162,7 @@ impl<H: 'static> Writer for H2Writer<H> {
if !self.flags.contains(Flags::DISCONNECTED) {
if self.flags.contains(Flags::STARTED) {
// TODO: add warning, write after EOF
self.encoder.write(payload)?;
self.encoder.write(payload.as_ref())?;
} else {
// might be response for EXCEPT
self.buffer.extend_from_slice(payload.as_ref())

9
src/server/shared.rs
View File

@ -48,10 +48,6 @@ impl Drop for SharedBytes {
}
impl SharedBytes {
pub fn empty() -> Self {
SharedBytes(None, None)
}
pub fn new(bytes: Rc<BytesMut>, pool: Rc<SharedBytesPool>) -> SharedBytes {
SharedBytes(Some(bytes), Some(pool))
}
@ -87,11 +83,6 @@ impl SharedBytes {
self.get_mut().take()
}
#[inline]
pub fn reserve(&self, cnt: usize) {
self.get_mut().reserve(cnt)
}
#[inline]
#[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
pub fn extend(&self, data: Binary) {

12
src/test.rs
View File

@ -60,7 +60,6 @@ use ws;
/// ```
pub struct TestServer {
addr: net::SocketAddr,
thread: Option<thread::JoinHandle<()>>,
server_sys: Addr<System>,
ssl: bool,
conn: Addr<ClientConnector>,
@ -107,7 +106,7 @@ impl TestServer {
let (tx, rx) = mpsc::channel();
// run server in separate thread
let join = thread::spawn(move || {
thread::spawn(move || {
let sys = System::new("actix-test-server");
let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
let local_addr = tcp.local_addr().unwrap();
@ -134,7 +133,6 @@ impl TestServer {
server_sys,
conn,
ssl: false,
thread: Some(join),
rt: Runtime::new().unwrap(),
}
}
@ -190,10 +188,7 @@ impl TestServer {
/// Stop http server
fn stop(&mut self) {
if let Some(handle) = self.thread.take() {
self.server_sys.do_send(msgs::SystemExit(0));
let _ = handle.join();
}
self.server_sys.do_send(msgs::SystemExit(0));
}
/// Execute future on current core
@ -287,7 +282,7 @@ impl<S: 'static> TestServerBuilder<S> {
let ssl = false;
// run server in separate thread
let join = thread::spawn(move || {
thread::spawn(move || {
let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
let local_addr = tcp.local_addr().unwrap();
@ -332,7 +327,6 @@ impl<S: 'static> TestServerBuilder<S> {
ssl,
conn,
server_sys,
thread: Some(join),
rt: Runtime::new().unwrap(),
}
}

8
src/ws/client.rs
View File

@ -7,7 +7,7 @@ use std::{fmt, io, str};
use base64;
use bytes::Bytes;
use cookie::Cookie;
use futures::unsync::mpsc::{unbounded, UnboundedSender};
use futures::sync::mpsc::{unbounded, UnboundedSender};
use futures::{Async, Future, Poll, Stream};
use http::header::{self, HeaderName, HeaderValue};
use http::{Error as HttpError, HttpTryFrom, StatusCode};
@ -16,14 +16,14 @@ use sha1::Sha1;
use actix::prelude::*;
use body::{Binary, Body};
use body::Binary;
use error::{Error, UrlParseError};
use header::IntoHeaderValue;
use httpmessage::HttpMessage;
use payload::PayloadHelper;
use client::{
ClientConnector, ClientRequest, ClientRequestBuilder, ClientResponse,
ClientBody, ClientConnector, ClientRequest, ClientRequestBuilder, ClientResponse,
HttpResponseParserError, SendRequest, SendRequestError,
};
@ -283,7 +283,7 @@ impl ClientHandshake {
);
let (tx, rx) = unbounded();
request.set_body(Body::Streaming(Box::new(rx.map_err(|_| {
request.set_body(ClientBody::Streaming(Box::new(rx.map_err(|_| {
io::Error::new(io::ErrorKind::Other, "disconnected").into()
}))));

3
src/ws/context.rs
View File

@ -1,5 +1,4 @@
use futures::sync::oneshot::Sender;
use futures::unsync::oneshot;
use futures::sync::oneshot::{self, Sender};
use futures::{Async, Poll};
use smallvec::SmallVec;

5
tests/test_client.rs
View File

@ -343,7 +343,10 @@ fn test_client_streaming_explicit() {
let body = once(Ok(Bytes::from_static(STR.as_ref())));
let request = srv.get().body(Body::Streaming(Box::new(body))).unwrap();
let request = srv
.get()
.body(client::ClientBody::Streaming(Box::new(body)))
.unwrap();
let response = srv.execute(request.send()).unwrap();
assert!(response.status().is_success());

18
tests/test_server.rs
View File

@ -32,7 +32,7 @@ use tokio::executor::current_thread;
use tokio::runtime::current_thread::Runtime;
use tokio_tcp::TcpStream;
use actix::System;
use actix::{msgs::SystemExit, Arbiter, System};
use actix_web::*;
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
@ -74,12 +74,11 @@ fn test_start() {
let srv = srv.bind("127.0.0.1:0").unwrap();
let addr = srv.addrs()[0];
let srv_addr = srv.start();
let _ = tx.send((addr, srv_addr));
let _ = tx.send((addr, srv_addr, Arbiter::system()));
});
});
let (addr, srv_addr) = rx.recv().unwrap();
let (addr, srv_addr, sys) = rx.recv().unwrap();
let _sys = System::new("test-server");
let mut rt = Runtime::new().unwrap();
{
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
@ -102,7 +101,7 @@ fn test_start() {
// resume
let _ = srv_addr.send(server::ResumeServer).wait();
thread::sleep(time::Duration::from_millis(400));
thread::sleep(time::Duration::from_millis(200));
{
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
.finish()
@ -110,6 +109,8 @@ fn test_start() {
let response = rt.block_on(req.send()).unwrap();
assert!(response.status().is_success());
}
let _ = sys.send(SystemExit(0)).wait();
}
#[test]
@ -129,12 +130,11 @@ fn test_shutdown() {
let srv = srv.bind("127.0.0.1:0").unwrap();
let addr = srv.addrs()[0];
let srv_addr = srv.shutdown_timeout(1).start();
let _ = tx.send((addr, srv_addr));
let _ = tx.send((addr, srv_addr, Arbiter::system()));
});
});
let (addr, srv_addr) = rx.recv().unwrap();
let (addr, srv_addr, sys) = rx.recv().unwrap();
let _sys = System::new("test-server");
let mut rt = Runtime::new().unwrap();
{
let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
@ -147,6 +147,8 @@ fn test_shutdown() {
thread::sleep(time::Duration::from_millis(1000));
assert!(net::TcpStream::connect(addr).is_err());
let _ = sys.send(SystemExit(0)).wait();
}
#[test]