Add streaming downloads with the stream_object Bucket method

Closes #10

Author: durch

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust-s3"
-version = "0.13.0"
+version = "0.14.0-beta.0"
 authors = ["Drazen Urch", "Nick Stevens"]
 description = "Tiny Rust library for working with Amazon S3."
 repository = "https://github.com/durch/rust-s3"

src/bucket.rs

@@ -3,6 +3,7 @@ use std::mem;
 
 use serde_xml;
 
+use std::io::Write;
 use credentials::Credentials;
 use command::Command;
 use region::Region;
@@ -85,9 +86,33 @@ impl Bucket {
         request.execute()
     }
 
+    /// Stream file from S3 path to a local file, generic over T: Write.
+    ///
+    /// # Example:
+    ///
+    /// ```rust,no_run
+    /// use s3::bucket::Bucket;
+    /// use s3::credentials::Credentials;
+    /// use std::fs::File;
+    ///
+    /// let bucket_name = "rust-s3-test";
+    /// let region = "us-east-1".parse().unwrap();
+    /// let credentials = Credentials::default();
+    /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
+    /// let mut output_file = File::create("output_file").expect("Unable to create file");
+    ///
+    /// let code = bucket.stream_object("/test.file", &mut output_file).unwrap();
+    /// println!("Code: {}", code);
+    /// ```
+    pub fn stream_object<T: Write>(&self, path: &str, writer: &mut T) -> S3Result<u32> {
+        let command = Command::GetObject;
+        let request = Request::new(self, path, command);
+        request.stream(writer)
+    }
+
 
     //// Get bucket location from S3
-////
+    ////
     /// # Example
     /// ```rust,no_run
     /// # // Fake  credentials so we don't access user's real credentials in tests
@@ -376,7 +401,7 @@ impl Bucket {
 
     /// Get a reference to the AWS token.
     pub fn token(&self) -> Option<&str> {
-        self.credentials.token.as_ref().map(|s| s.as_str())
+        self.credentials.token.as_ref().map(std::string::String::as_str)
     }
 
     /// Get a reference to the full [`Credentials`](struct.Credentials.html)

src/request.rs

@@ -2,7 +2,7 @@ extern crate base64;
 extern crate md5;
 
 use std::collections::HashMap;
-use std::io::Read;
+use std::io::{Read, Write};
 
 use bucket::Bucket;
 use chrono::{DateTime, Utc};
@@ -222,6 +222,16 @@ impl<'a> Request<'a> {
     }
 
     pub fn execute(&self) -> S3Result<(Vec<u8>, u32)> {
+        let response_tuple = self.maybe_stream::<Vec<u8>>(None)?;
+        Ok((response_tuple.0.unwrap(), response_tuple.1))
+    }
+
+    pub fn stream<T: Write>(&self, writer: &mut T) -> S3Result<u32> {
+        let response_tuple = self.maybe_stream(Some(writer))?;
+        Ok(response_tuple.1)
+    }
+
+    pub fn maybe_stream<T: Write>(&self, writer: Option<&mut T>) -> S3Result<(Option<Vec<u8>>, u32)> {
         // TODO: preserve client across requests
         let client = if cfg!(feature = "no-verify-ssl") {
             reqwest::Client::builder()
@@ -250,13 +260,21 @@ impl<'a> Request<'a> {
             .body(content);
         let mut response = request.send()?;
 
-        // Read and process response
+        let resp_code = u32::from(response.status().as_u16());
+
+        let ret;
         let mut dst = Vec::new();
-        response.read_to_end(&mut dst)?;
 
-        let resp_code = u32::from(response.status().as_u16());
         if resp_code < 300 {
-            Ok((dst, resp_code))
+            // Read and process response
+            if let Some(wrt) = writer {
+                response.copy_to(wrt)?;
+                ret = None;
+            } else {
+                response.copy_to(&mut dst)?;
+                ret = Some(dst)
+            }
+            Ok((ret, resp_code))
         } else {
             let deserialized: AwsError = serde_xml::deserialize(dst.as_slice())?;
             let err = ErrorKind::AwsError {