fix(client): check for drained stream in Response::drop

src/client/pool.rs

@@ -116,7 +116,6 @@ impl<C: NetworkConnector<Stream=S>, S: NetworkStream + Send> NetworkConnector fo
  Ok(PooledStream {
  inner: Some((key, conn)),
  is_closed: false,
- is_drained: false,
  pool: self.inner.clone()
  })
  }
@@ -130,20 +129,13 @@ impl<C: NetworkConnector<Stream=S>, S: NetworkStream + Send> NetworkConnector fo
 pub struct PooledStream<S> {
  inner: Option<(Key, S)>,
  is_closed: bool,
- is_drained: bool,
  pool: Arc<Mutex<PoolImpl<S>>>
 }
 
 impl<S: NetworkStream> Read for PooledStream<S> {
  #[inline]
  fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- match self.inner.as_mut().unwrap().1.read(buf) {
- Ok(0) => {
- self.is_drained = true;
- Ok(0)
- }
- r => r
- }
+ self.inner.as_mut().unwrap().1.read(buf)
  }
 }
 
@@ -174,8 +166,8 @@ impl<S: NetworkStream> NetworkStream for PooledStream<S> {
 
 impl<S> Drop for PooledStream<S> {
  fn drop(&mut self) {
- trace!("PooledStream.drop, is_closed={}, is_drained={}", self.is_closed, self.is_drained);
- if !self.is_closed && self.is_drained {
+ trace!("PooledStream.drop, is_closed={}", self.is_closed);
+ if !self.is_closed {
  self.inner.take().map(|(key, conn)| {
  if let Ok(mut pool) = self.pool.lock() {
  pool.reuse(key, conn);
@@ -205,13 +197,13 @@ mod tests {
  fn test_connect_and_drop() {
  let pool = mocked!();
  let key = key("127.0.0.1", 3000, "http");
- pool.connect("127.0.0.1", 3000, "http").unwrap().is_drained = true;
+ pool.connect("127.0.0.1", 3000, "http").unwrap();
  {
  let locked = pool.inner.lock().unwrap();
  assert_eq!(locked.conns.len(), 1);
  assert_eq!(locked.conns.get(&key).unwrap().len(), 1);
  }
- pool.connect("127.0.0.1", 3000, "http").unwrap().is_drained = true; //reused
+ pool.connect("127.0.0.1", 3000, "http").unwrap(); //reused
  {
  let locked = pool.inner.lock().unwrap();
  assert_eq!(locked.conns.len(), 1);

src/client/response.rs

@@ -19,6 +19,7 @@ pub struct Response {
  pub version: version::HttpVersion,
  status_raw: RawStatus,
  message: Box<HttpMessage>,
+ is_drained: bool,
 }
 
 impl Response {
@@ -43,41 +44,54 @@ impl Response {
  headers: headers,
  message: message,
  status_raw: raw_status,
+ is_drained: false,
  })
  }
 
  /// Get the raw status code and reason.
  pub fn status_raw(&self) -> &RawStatus {
  &self.status_raw
  }
+
 }
 
 impl Read for Response {
  #[inline]
  fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- let count = try!(self.message.read(buf));
+ match self.message.read(buf) {
+ Ok(0) => {
+ self.is_drained = true;
+ Ok(0)
+ },
+ r => r
+ }
+ }
+}
 
- if count == 0 {
- if !http::should_keep_alive(self.version, &self.headers) {
- try!(self.message.close_connection()
- .map_err(|_| io::Error::new(io::ErrorKind::Other,
- "Error closing connection")));
+impl Drop for Response {
+ fn drop(&mut self) {
+ // if not drained, theres old bits in the Reader. we can't reuse this,
+ // since those old bits would end up in new Responses
+ //
+ // otherwise, the response has been drained. we should check that the
+ // server has agreed to keep the connection open
+ trace!("Response.is_drained = {:?}", self.is_drained);
+ if !(self.is_drained && http::should_keep_alive(self.version, &self.headers)) {
+ trace!("closing connection");
+ if let Err(e) = self.message.close_connection() {
+ error!("error closing connection: {}", e);
  }
  }
-
- Ok(count)
  }
 }
 
 #[cfg(test)]
 mod tests {
- use std::borrow::Cow::Borrowed;
  use std::io::{self, Read};
 
- use header::Headers;
  use header::TransferEncoding;
  use header::Encoding;
- use http::RawStatus;
+ use http::HttpMessage;
  use mock::MockStream;
  use status;
  use version;
@@ -94,18 +108,10 @@ mod tests {
 
  #[test]
  fn test_into_inner() {
- let res = Response {
- status: status::StatusCode::Ok,
- headers: Headers::new(),
- version: version::HttpVersion::Http11,
- message: Box::new(Http11Message::with_stream(Box::new(MockStream::new()))),
- status_raw: RawStatus(200, Borrowed("OK")),
- };
-
- let message = res.message.downcast::<Http11Message>().ok().unwrap();
+ let message: Box<HttpMessage> = Box::new(Http11Message::with_stream(Box::new(MockStream::new())));
+ let message = message.downcast::<Http11Message>().ok().unwrap();
  let b = message.into_inner().downcast::<MockStream>().ok().unwrap();
  assert_eq!(b, Box::new(MockStream::new()));
-
  }
 
  #[test]

src/http/mod.rs

@@ -20,6 +20,7 @@ pub struct RawStatus(pub u16, pub Cow<'static, str>);
 /// Checks if a connection should be kept alive.
 #[inline]
 pub fn should_keep_alive(version: HttpVersion, headers: &Headers) -> bool {
+ trace!("should_keep_alive( {:?}, {:?} )", version, headers.get::<Connection>());
  match (version, headers.get::<Connection>()) {
  (Http10, Some(conn)) if !conn.contains(&KeepAlive) => false,
  (Http11, Some(conn)) if conn.contains(&Close) => false,