prepare release of version 2.0, regen all APIs

gen/cloudmonitoring2_beta2/src/client.rs

@@ -1,24 +1,34 @@
-// COPY OF 'src/rust/api/cmn.rs'
+// COPY OF 'src/rust/api/client.rs'
 // DO NOT EDIT
-use std::io::{self, Read, Seek, Cursor, Write, SeekFrom};
 use std;
-use std::fmt::{self, Display};
-use std::str::FromStr;
 use std::error;
+use std::fmt::{self, Display};
+use std::io::{self, Cursor, Read, Seek, SeekFrom, Write};
+use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;
 
-use mime::{Mime, TopLevel, SubLevel, Attr, Value};
-use oauth2::{TokenType, Retry, self};
+use itertools::Itertools;
+
 use hyper;
-use hyper::header::{ContentType, ContentLength, Headers, UserAgent, Authorization, Header,
-                    HeaderFormat, Bearer};
-use hyper::http::h1::LINE_ENDING;
-use hyper::method::Method;
-use hyper::status::StatusCode;
+use hyper::header::{HeaderMap, AUTHORIZATION, CONTENT_LENGTH, CONTENT_TYPE, USER_AGENT};
+use hyper::Method;
+use hyper::StatusCode;
+
+use mime::{Attr, Mime, SubLevel, TopLevel, Value};
+use oauth2;
 
 use serde_json as json;
 
+const LINE_ENDING: &'static str = "\r\n";
+
+pub enum Retry {
+    /// Signal you don't want to retry
+    Abort,
+    /// Signals you want to retry after the given duration
+    After(Duration),
+}
+
 /// Identifies the Hub. There is only one per library, this trait is supposed
 /// to make intended use more explicit.
 /// The hub allows to access all resource methods more easily.
@@ -65,7 +75,7 @@ pub trait ToParts {
 #[derive(Deserialize)]
 pub struct JsonServerError {
     pub error: String,
-    pub error_description: Option<String>
+    pub error_description: Option<String>,
 }
 
 /// A utility to represent detailed errors we might see in case there are BadRequests.
@@ -87,67 +97,32 @@ pub struct ServerMessage {
     pub domain: String,
     pub reason: String,
     pub message: String,
-    #[serde(rename="locationType")]
+    #[serde(rename = "locationType")]
     pub location_type: Option<String>,
-    pub location: Option<String>
+    pub location: Option<String>,
 }
 
-#[derive(Copy, Clone)]
-pub struct DummyNetworkStream;
-
-impl Read for DummyNetworkStream {
-    fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-        Ok(0)
-    }
-}
-
-impl Write for DummyNetworkStream {
-    fn write(&mut self, _: &[u8]) -> io::Result<usize> {
-        Ok(0)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl hyper::net::NetworkStream for DummyNetworkStream {
-    fn peer_addr(&mut self) -> io::Result<std::net::SocketAddr> {
-        Ok("127.0.0.1:1337".parse().unwrap())
-    }
-
-    fn set_read_timeout(&self, _dur: Option<Duration>) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn set_write_timeout(&self, _dur: Option<Duration>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-
 /// A trait specifying functionality to help controlling any request performed by the API.
 /// The trait has a conservative default implementation.
 ///
 /// It contains methods to deal with all common issues, as well with the ones related to
 /// uploading media
 pub trait Delegate {
-
     /// Called at the beginning of any API request. The delegate should store the method
     /// information if he is interesting in knowing more context when further calls to it
     /// are made.
     /// The matching `finished()` call will always be made, no matter whether or not the API
     /// request was successful. That way, the delegate may easily maintain a clean state
     /// between various API calls.
-    fn begin(&mut self, MethodInfo) {}
+    fn begin(&mut self, _info: MethodInfo) {}
 
-    /// Called whenever there is an [HttpError](http://hyperium.github.io/hyper/hyper/error/enum.HttpError.html), usually if there are network problems.
+    /// Called whenever there is an [HttpError](hyper::Error), usually if there are network problems.
     ///
     /// If you choose to retry after a duration, the duration should be chosen using the
     /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff).
     ///
     /// Return retry information.
-    fn http_error(&mut self, &hyper::Error) -> Retry {
+    fn http_error(&mut self, _err: &hyper::Error) -> Retry {
         Retry::Abort
     }
 
@@ -163,7 +138,7 @@ pub trait Delegate {
     /// impending failure.
     /// The given Error provides information about why the token couldn't be acquired in the
     /// first place
-    fn token(&mut self, err: &dyn error::Error) -> Option<oauth2::Token> {
+    fn token(&mut self, err: &oauth2::Error) -> Option<oauth2::AccessToken> {
         let _ = err;
         None
     }
@@ -197,7 +172,11 @@ pub trait Delegate {
     ///
     /// * `json_encoded_value` - The json-encoded value which failed to decode.
     /// * `json_decode_error`  - The decoder error
-    fn response_json_decode_error(&mut self, json_encoded_value: &str, json_decode_error: &json::Error) {
+    fn response_json_decode_error(
+        &mut self,
+        json_encoded_value: &str,
+        json_decode_error: &json::Error,
+    ) {
         let _ = json_encoded_value;
         let _ = json_decode_error;
     }
@@ -210,14 +189,19 @@ pub trait Delegate {
     ///
     /// If you choose to retry after a duration, the duration should be chosen using the
     /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff).
-    fn http_failure(&mut self, _: &hyper::client::Response, Option<JsonServerError>, _: Option<ServerError>) -> Retry {
+    fn http_failure(
+        &mut self,
+        _: &hyper::Response<hyper::body::Body>,
+        _err: Option<JsonServerError>,
+        _: Option<ServerError>,
+    ) -> Retry {
         Retry::Abort
     }
 
     /// Called prior to sending the main request of the given method. It can be used to time
     /// the call or to print progress information.
     /// It's also useful as you can be sure that a request will definitely be made.
-    fn pre_request(&mut self) { }
+    fn pre_request(&mut self) {}
 
     /// Return the size of each chunk of a resumable upload.
     /// Must be a power of two, with 1<<18 being the smallest allowed chunk size.
@@ -255,7 +239,6 @@ pub struct DefaultDelegate;
 
 impl Delegate for DefaultDelegate {}
 
-
 #[derive(Debug)]
 pub enum Error {
     /// The http connection failed
@@ -274,7 +257,7 @@ pub enum Error {
     MissingAPIKey,
 
     /// We required a Token, but didn't get one from the Authenticator
-    MissingToken(Box<dyn error::Error>),
+    MissingToken(oauth2::Error),
 
     /// The delgate instructed to cancel the operation
     Cancelled,
@@ -287,67 +270,83 @@ pub enum Error {
     JsonDecodeError(String, json::Error),
 
     /// Indicates an HTTP repsonse with a non-success status code
-    Failure(hyper::client::Response),
-}
+    Failure(hyper::Response<hyper::body::Body>),
 
+    /// An IO error occurred while reading a stream into memory
+    Io(std::io::Error),
+}
 
 impl Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            Error::Io(ref err) => err.fmt(f),
             Error::HttpError(ref err) => err.fmt(f),
-            Error::UploadSizeLimitExceeded(ref resource_size, ref max_size) =>
-                writeln!(f, "The media size {} exceeds the maximum allowed upload size of {}"
-                         , resource_size, max_size),
+            Error::UploadSizeLimitExceeded(ref resource_size, ref max_size) => writeln!(
+                f,
+                "The media size {} exceeds the maximum allowed upload size of {}",
+                resource_size, max_size
+            ),
             Error::MissingAPIKey => {
-                (writeln!(f, "The application's API key was not found in the configuration")).ok();
-                writeln!(f, "It is used as there are no Scopes defined for this method.")
-            },
+                (writeln!(
+                    f,
+                    "The application's API key was not found in the configuration"
+                ))
+                .ok();
+                writeln!(
+                    f,
+                    "It is used as there are no Scopes defined for this method."
+                )
+            }
             Error::BadRequest(ref err) => {
                 writeln!(f, "Bad Request ({}): {}", err.error.code, err.error.message)?;
                 for err in err.error.errors.iter() {
-                    writeln!(f, "    {}: {}, {}{}",
-                             err.domain,
-                             err.message,
-                             err.reason,
-                             match &err.location {
-                                 &Some(ref loc) => format!("@{}", loc),
-                                 &None => String::new(),
-                             })?;
+                    writeln!(
+                        f,
+                        "    {}: {}, {}{}",
+                        err.domain,
+                        err.message,
+                        err.reason,
+                        match &err.location {
+                            &Some(ref loc) => format!("@{}", loc),
+                            &None => String::new(),
+                        }
+                    )?;
                 }
                 Ok(())
-            },
-            Error::MissingToken(ref err) =>
-                writeln!(f, "Token retrieval failed with error: {}", err),
-            Error::Cancelled =>
-                writeln!(f, "Operation cancelled by delegate"),
-            Error::FieldClash(field) =>
-                writeln!(f, "The custom parameter '{}' is already provided natively by the CallBuilder.", field),
-            Error::JsonDecodeError(ref json_str, ref err)
-                => writeln!(f, "{}: {}", err, json_str),
-            Error::Failure(ref response) =>
-                writeln!(f, "Http status indicates failure: {:?}", response),
+            }
+            Error::MissingToken(ref err) => {
+                writeln!(f, "Token retrieval failed with error: {}", err)
+            }
+            Error::Cancelled => writeln!(f, "Operation cancelled by delegate"),
+            Error::FieldClash(field) => writeln!(
+                f,
+                "The custom parameter '{}' is already provided natively by the CallBuilder.",
+                field
+            ),
+            Error::JsonDecodeError(ref json_str, ref err) => writeln!(f, "{}: {}", err, json_str),
+            Error::Failure(ref response) => {
+                writeln!(f, "Http status indicates failure: {:?}", response)
+            }
         }
     }
 }
 
 impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::HttpError(ref err) => err.description(),
-            Error::JsonDecodeError(_, ref err) => err.description(),
-            _ => "NO DESCRIPTION POSSIBLE - use `Display.fmt()` instead"
-        }
-    }
-
-    fn cause(&self) -> Option<&dyn error::Error> {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
             Error::HttpError(ref err) => err.source(),
             Error::JsonDecodeError(_, ref err) => err.source(),
-            _ => None
+            _ => None,
         }
     }
 }
 
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
 /// A universal result type used as return for all calls.
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -365,13 +364,12 @@ const BOUNDARY: &'static str = "MDuXWGyeE33QFXGchb2VFWc4Z7945d";
 /// to google APIs, and might not be a fully-featured implementation.
 #[derive(Default)]
 pub struct MultiPartReader<'a> {
-    raw_parts: Vec<(Headers, &'a mut dyn Read)>,
+    raw_parts: Vec<(HeaderMap, &'a mut dyn Read)>,
     current_part: Option<(Cursor<Vec<u8>>, &'a mut dyn Read)>,
     last_part_boundary: Option<Cursor<Vec<u8>>>,
 }
 
 impl<'a> MultiPartReader<'a> {
-
     /// Reserve memory for exactly the given amount of parts
     pub fn reserve_exact(&mut self, cap: usize) {
         self.raw_parts.reserve_exact(cap);
@@ -388,10 +386,18 @@ impl<'a> MultiPartReader<'a> {
     /// `size`    - the amount of bytes provided by the reader. It will be put onto the header as
     ///             content-size.
     /// `mime`    - It will be put onto the content type
-    pub fn add_part(&mut self, reader: &'a mut dyn Read, size: u64, mime_type: Mime) -> &mut MultiPartReader<'a> {
-        let mut headers = Headers::new();
-        headers.set(ContentType(mime_type));
-        headers.set(ContentLength(size));
+    pub fn add_part(
+        &mut self,
+        reader: &'a mut dyn Read,
+        size: u64,
+        mime_type: Mime,
+    ) -> &mut MultiPartReader<'a> {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            CONTENT_TYPE,
+            hyper::header::HeaderValue::from_str(&format!("{}", mime_type)).unwrap(),
+        );
+        headers.insert(CONTENT_LENGTH, size.into());
         self.raw_parts.push((headers, reader));
         self
     }
@@ -402,13 +408,18 @@ impl<'a> MultiPartReader<'a> {
         Mime(
             TopLevel::Multipart,
             SubLevel::Ext("Related".to_string()),
-            vec![(Attr::Ext("boundary".to_string()), Value::Ext(BOUNDARY.to_string()))],
+            vec![(
+                Attr::Ext("boundary".to_string()),
+                Value::Ext(BOUNDARY.to_string()),
+            )],
         )
     }
 
     /// Returns true if we are totally used
     fn is_depleted(&self) -> bool {
-        self.raw_parts.len() == 0 && self.current_part.is_none() && self.last_part_boundary.is_none()
+        self.raw_parts.len() == 0
+            && self.current_part.is_none()
+            && self.last_part_boundary.is_none()
     }
 
     /// Returns true if we are handling our last part
@@ -419,26 +430,44 @@ impl<'a> MultiPartReader<'a> {
 
 impl<'a> Read for MultiPartReader<'a> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match (self.raw_parts.len(),
-               self.current_part.is_none(),
-               self.last_part_boundary.is_none()) {
+        match (
+            self.raw_parts.len(),
+            self.current_part.is_none(),
+            self.last_part_boundary.is_none(),
+        ) {
             (_, _, false) => {
-                let br = self.last_part_boundary.as_mut().unwrap().read(buf).unwrap_or(0);
+                let br = self
+                    .last_part_boundary
+                    .as_mut()
+                    .unwrap()
+                    .read(buf)
+                    .unwrap_or(0);
                 if br < buf.len() {
                     self.last_part_boundary = None;
                 }
-                return Ok(br)
-            },
+                return Ok(br);
+            }
             (0, true, true) => return Ok(0),
             (n, true, _) if n > 0 => {
                 let (headers, reader) = self.raw_parts.remove(0);
                 let mut c = Cursor::new(Vec::<u8>::new());
-                (write!(&mut c, "{}--{}{}{}{}", LINE_ENDING, BOUNDARY, LINE_ENDING,
-                                                headers, LINE_ENDING)).unwrap();
+                (write!(
+                    &mut c,
+                    "{}--{}{}{}{}",
+                    LINE_ENDING,
+                    BOUNDARY,
+                    LINE_ENDING,
+                    headers
+                        .iter()
+                        .map(|(k, v)| format!("{}: {}", k, v.to_str().unwrap()))
+                        .join(LINE_ENDING),
+                    LINE_ENDING
+                ))
+                .unwrap();
                 c.seek(SeekFrom::Start(0)).unwrap();
                 self.current_part = Some((c, reader));
             }
-            _ => {},
+            _ => {}
         }
 
         // read headers as long as possible
@@ -455,14 +484,15 @@ impl<'a> Read for MultiPartReader<'a> {
                         // before clearing the last part, we will add the boundary that
                         // will be written last
                         self.last_part_boundary = Some(Cursor::new(
-                                                        format!("{}--{}--", LINE_ENDING, BOUNDARY).into_bytes()))
+                            format!("{}--{}--", LINE_ENDING, BOUNDARY).into_bytes(),
+                        ))
                     }
                     // We are depleted - this can trigger the next part to come in
                     self.current_part = None;
                 }
                 let mut total_bytes_read = hb + bytes_read;
                 while total_bytes_read < buf.len() && !self.is_depleted() {
-                    match self.read(&mut buf[total_bytes_read ..]) {
+                    match self.read(&mut buf[total_bytes_read..]) {
                         Ok(br) => total_bytes_read += br,
                         Err(err) => return Err(err),
                     }
@@ -489,20 +519,13 @@ pub struct XUploadContentType(pub Mime);
 
 impl ::std::ops::Deref for XUploadContentType {
     type Target = Mime;
-    fn deref<'a>(&'a self) -> &'a Mime { &self.0 }
-}
-impl ::std::ops::DerefMut for XUploadContentType {
-    fn deref_mut<'a>(&'a mut self) -> &'a mut Mime { &mut self.0 }
-}
-impl Header for XUploadContentType {
-    fn header_name() -> &'static str { "X-Upload-Content-Type" }
-    fn parse_header(raw: &[Vec<u8>]) -> hyper::error::Result<Self> {
-        hyper::header::parsing::from_one_raw_str(raw).map(XUploadContentType)
+    fn deref<'a>(&'a self) -> &'a Mime {
+        &self.0
     }
 }
-impl HeaderFormat for XUploadContentType {
-    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&**self, f)
+impl ::std::ops::DerefMut for XUploadContentType {
+    fn deref_mut<'a>(&'a mut self) -> &'a mut Mime {
+        &mut self.0
     }
 }
 impl Display for XUploadContentType {
@@ -514,7 +537,7 @@ impl Display for XUploadContentType {
 #[derive(Clone, PartialEq, Debug)]
 pub struct Chunk {
     pub first: u64,
-    pub last: u64
+    pub last: u64,
 }
 
 impl fmt::Display for Chunk {
@@ -531,20 +554,18 @@ impl FromStr for Chunk {
     fn from_str(s: &str) -> std::result::Result<Chunk, &'static str> {
         let parts: Vec<&str> = s.split('-').collect();
         if parts.len() != 2 {
-            return Err("Expected two parts: %i-%i")
+            return Err("Expected two parts: %i-%i");
         }
-        Ok(
-            Chunk {
-                first: match FromStr::from_str(parts[0]) {
-                    Ok(d) => d,
-                    _ => return Err("Couldn't parse 'first' as digit")
-                },
-                last: match FromStr::from_str(parts[1]) {
-                    Ok(d) => d,
-                    _ => return Err("Couldn't parse 'last' as digit")
-                }
-            }
-        )
+        Ok(Chunk {
+            first: match FromStr::from_str(parts[0]) {
+                Ok(d) => d,
+                _ => return Err("Couldn't parse 'first' as digit"),
+            },
+            last: match FromStr::from_str(parts[1]) {
+                Ok(d) => d,
+                _ => return Err("Couldn't parse 'last' as digit"),
+            },
+        })
     }
 }
 
@@ -555,106 +576,105 @@ pub struct ContentRange {
     pub total_length: u64,
 }
 
-impl Header for ContentRange {
-    fn header_name() -> &'static str {
-        "Content-Range"
-    }
-
-    /// We are not parsable, as parsing is done by the `Range` header
-    fn parse_header(_: &[Vec<u8>]) -> hyper::error::Result<Self> {
-        Err(hyper::error::Error::Method)
-    }
-}
-
-
-impl HeaderFormat for ContentRange {
-    fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.write_str("bytes ")?;
-        match self.range {
-            Some(ref c) => c.fmt(fmt)?,
-            None => fmt.write_str("*")?
-        }
-        (write!(fmt, "/{}", self.total_length)).ok();
-        Ok(())
+impl ContentRange {
+    pub fn header_value(&self) -> String {
+        format!(
+            "bytes {}/{}",
+            match self.range {
+                Some(ref c) => format!("{}", c),
+                None => "*".to_string(),
+            },
+            self.total_length
+        )
     }
 }
 
 #[derive(Clone, PartialEq, Debug)]
 pub struct RangeResponseHeader(pub Chunk);
 
-impl Header for RangeResponseHeader {
-    fn header_name() -> &'static str {
-        "Range"
-    }
-
-    fn parse_header(raw: &[Vec<u8>]) -> hyper::error::Result<Self> {
+impl RangeResponseHeader {
+    fn from_bytes(raw: &[u8]) -> Self {
         if raw.len() > 0 {
-            let v = &raw[0];
-            if let Ok(s) = std::str::from_utf8(v) {
+            if let Ok(s) = std::str::from_utf8(raw) {
                 const PREFIX: &'static str = "bytes ";
                 if s.starts_with(PREFIX) {
                     if let Ok(c) = <Chunk as FromStr>::from_str(&s[PREFIX.len()..]) {
-                        return  Ok(RangeResponseHeader(c))
+                        return RangeResponseHeader(c);
                     }
                 }
             }
         }
-        Err(hyper::error::Error::Method)
-    }
-}
 
-impl HeaderFormat for RangeResponseHeader {
-    /// No implmentation necessary, we just need to parse
-    fn fmt_header(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        Err(fmt::Error)
+        panic!("Unable to parse Range header {:?}", raw)
     }
 }
 
 /// A utility type to perform a resumable upload from start to end.
 pub struct ResumableUploadHelper<'a, A: 'a> {
-    pub client: &'a mut hyper::client::Client,
+    pub client: &'a mut hyper::client::Client<
+        hyper_rustls::HttpsConnector<hyper::client::connect::HttpConnector>,
+        hyper::body::Body,
+    >,
     pub delegate: &'a mut dyn Delegate,
     pub start_at: Option<u64>,
     pub auth: &'a mut A,
     pub user_agent: &'a str,
-    pub auth_header: Authorization<Bearer>,
+    pub auth_header: String,
     pub url: &'a str,
     pub reader: &'a mut dyn ReadSeek,
     pub media_type: Mime,
-    pub content_length: u64
+    pub content_length: u64,
 }
 
-impl<'a, A> ResumableUploadHelper<'a, A>
-    where A: oauth2::GetToken {
-
-    fn query_transfer_status(&mut self) -> std::result::Result<u64, hyper::Result<hyper::client::Response>> {
+impl<'a, A> ResumableUploadHelper<'a, A> {
+    async fn query_transfer_status(
+        &mut self,
+    ) -> std::result::Result<u64, hyper::Result<hyper::Response<hyper::body::Body>>> {
         loop {
-            match self.client.post(self.url)
-                .header(UserAgent(self.user_agent.to_string()))
-                .header(ContentRange { range: None, total_length: self.content_length })
-                .header(self.auth_header.clone())
-                .send() {
+            match self
+                .client
+                .request(
+                    hyper::Request::builder()
+                        .method(hyper::Method::POST)
+                        .uri(self.url)
+                        .header(USER_AGENT, self.user_agent.to_string())
+                        .header(
+                            "Content-Range",
+                            ContentRange {
+                                range: None,
+                                total_length: self.content_length,
+                            }
+                            .header_value(),
+                        )
+                        .header(AUTHORIZATION, self.auth_header.clone())
+                        .body(hyper::body::Body::empty())
+                        .unwrap(),
+                )
+                .await
+            {
                 Ok(r) => {
                     // 308 = resume-incomplete == PermanentRedirect
-                    let headers = r.headers.clone();
-                    let h: &RangeResponseHeader = match headers.get() {
-                        Some(hh) if r.status == StatusCode::PermanentRedirect => hh,
-                        None|Some(_) => {
+                    let headers = r.headers().clone();
+                    let h: RangeResponseHeader = match headers.get("Range") {
+                        Some(hh) if r.status() == StatusCode::PERMANENT_REDIRECT => {
+                            RangeResponseHeader::from_bytes(hh.as_bytes())
+                        }
+                        None | Some(_) => {
                             if let Retry::After(d) = self.delegate.http_failure(&r, None, None) {
                                 sleep(d);
                                 continue;
                             }
-                            return Err(Ok(r))
+                            return Err(Ok(r));
                         }
                     };
-                    return Ok(h.0.last)
+                    return Ok(h.0.last);
                 }
                 Err(err) => {
                     if let Retry::After(d) = self.delegate.http_error(&err) {
                         sleep(d);
                         continue;
                     }
-                    return Err(Err(err))
+                    return Err(Err(err));
                 }
             }
         }
@@ -663,73 +683,97 @@ impl<'a, A> ResumableUploadHelper<'a, A>
     /// returns None if operation was cancelled by delegate, or the HttpResult.
     /// It can be that we return the result just because we didn't understand the status code -
     /// caller should check for status himself before assuming it's OK to use
-    pub fn upload(&mut self) -> Option<hyper::Result<hyper::client::Response>> {
+    pub async fn upload(&mut self) -> Option<hyper::Result<hyper::Response<hyper::body::Body>>> {
         let mut start = match self.start_at {
             Some(s) => s,
-            None => match self.query_transfer_status() {
+            None => match self.query_transfer_status().await {
                 Ok(s) => s,
-                Err(result) => return Some(result)
-            }
+                Err(result) => return Some(result),
+            },
         };
 
         const MIN_CHUNK_SIZE: u64 = 1 << 18;
         let chunk_size = match self.delegate.chunk_size() {
             cs if cs > MIN_CHUNK_SIZE => cs,
-            _ => MIN_CHUNK_SIZE
+            _ => MIN_CHUNK_SIZE,
         };
 
         self.reader.seek(SeekFrom::Start(start)).unwrap();
         loop {
             let request_size = match self.content_length - start {
                 rs if rs > chunk_size => chunk_size,
-                rs => rs
+                rs => rs,
             };
 
             let mut section_reader = self.reader.take(request_size);
+            let mut req_bytes = vec![];
+            section_reader.read_to_end(&mut req_bytes).unwrap();
             let range_header = ContentRange {
-                range: Some(Chunk {first: start, last: start + request_size - 1}),
-                total_length: self.content_length
+                range: Some(Chunk {
+                    first: start,
+                    last: start + request_size - 1,
+                }),
+                total_length: self.content_length,
             };
             start += request_size;
             if self.delegate.cancel_chunk_upload(&range_header) {
-                return None
+                return None;
             }
-            let res = self.client.post(self.url)
-                                 .header(range_header)
-                                 .header(ContentType(self.media_type.clone()))
-                                 .header(UserAgent(self.user_agent.to_string()))
-                                 .body(&mut section_reader)
-                                 .send();
+            let res = self
+                .client
+                .request(
+                    hyper::Request::builder()
+                        .method(hyper::Method::POST)
+                        .header("Content-Range", range_header.header_value())
+                        .header(CONTENT_TYPE, format!("{}", self.media_type))
+                        .header(USER_AGENT, self.user_agent.to_string())
+                        .body(hyper::body::Body::from(req_bytes))
+                        .unwrap(),
+                )
+                .await;
             match res {
-                Ok(mut res) => {
-                    if res.status == StatusCode::PermanentRedirect  {
-                        continue
+                Ok(res) => {
+                    if res.status() == StatusCode::PERMANENT_REDIRECT {
+                        continue;
                     }
-                    if !res.status.is_success() {
-                        let mut json_err = String::new();
-                        res.read_to_string(&mut json_err).unwrap();
-                        if let Retry::After(d) = self.delegate.http_failure(&res,
-                                                        json::from_str(&json_err).ok(),
-                                                        json::from_str(&json_err).ok()) {
+
+                    let (res_parts, res_body) = res.into_parts();
+                    let res_body_string: String = String::from_utf8(
+                        hyper::body::to_bytes(res_body)
+                            .await
+                            .unwrap()
+                            .into_iter()
+                            .collect(),
+                    )
+                    .unwrap();
+                    let reconstructed_result =
+                        hyper::Response::from_parts(res_parts, res_body_string.clone().into());
+
+                    if !reconstructed_result.status().is_success() {
+                        if let Retry::After(d) = self.delegate.http_failure(
+                            &reconstructed_result,
+                            json::from_str(&res_body_string).ok(),
+                            json::from_str(&res_body_string).ok(),
+                        ) {
                             sleep(d);
                             continue;
                         }
                     }
-                    return Some(Ok(res))
-                },
+                    return Some(Ok(reconstructed_result));
+                }
                 Err(err) => {
                     if let Retry::After(d) = self.delegate.http_error(&err) {
                         sleep(d);
                         continue;
                     }
-                    return Some(Err(err))
+                    return Some(Err(err));
                 }
             }
         }
     }
 }
 
-// Copy of src/rust/cli/cmn.rs
+// Copy of src/rust/cli/client.rs
 // TODO(ST): Allow sharing common code between program types
 pub fn remove_json_null_values(value: &mut json::value::Value) {
     match *value {