fix(version-up): code updated to v0.1.6, latest CLI

* also includes publishing tag files

gen/analytics3/src/cmn.rs

@@ -60,7 +60,6 @@ pub trait ToParts {
     fn to_parts(&self) -> String;
 }
 
-
 /// A utility type which can decode a server response that indicates error
 #[derive(Deserialize)]
 pub struct JsonServerError {
@@ -68,6 +67,30 @@ pub struct JsonServerError {
     pub error_description: Option<String>
 }
 
+/// A utility to represent detailed errors we might see in case there are BadRequests.
+/// The latter happen if the sent parameters or request structures are unsound
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ErrorResponse {
+    error: ServerError,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ServerError {
+    errors: Vec<ServerMessage>,
+    code: u16,
+    message: String,   
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ServerMessage {
+    domain: String,
+    reason: String,
+    message: String,
+    #[serde(rename="locationType")]
+    location_type: Option<String>,
+    location: Option<String>
+}
+
 #[derive(Copy, Clone)]
 pub struct DummyNetworkStream;
 
@@ -175,7 +198,7 @@ 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>) -> Retry {
+    fn http_failure(&mut self, _: &hyper::client::Response, Option<JsonServerError>, _: Option<ServerError>) -> Retry {
         Retry::Abort
     }
 
@@ -230,6 +253,10 @@ pub enum Error {
     /// even though the maximum upload size is what is stored in field `.1`.
     UploadSizeLimitExceeded(u64, u64),
 
+    /// Represents information about a request that was not understood by the server.
+    /// Details are included.
+    BadRequest(ErrorResponse),
+
     /// We needed an API key for authentication, but didn't obtain one.
     /// Neither through the authenticator, nor through the Delegate.
     MissingAPIKey,
@@ -245,7 +272,7 @@ pub enum Error {
 
     /// Shows that we failed to decode the server response.
     /// This can happen if the protocol changes in conjunction with strict json decoding.
-    JsonDecodeError(serde::json::Error),
+    JsonDecodeError(String, serde::json::Error),
 
     /// Indicates an HTTP repsonse with a non-success status code
     Failure(hyper::client::Response),
@@ -263,13 +290,16 @@ impl Display for Error {
                 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 Requst ({}): {}", err.error.code, err.error.message),
             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 err) => err.fmt(f),
+            Error::JsonDecodeError(ref json_str, ref err) 
+                => writeln!(f, "{}: {}", err, json_str),
             Error::Failure(ref response) => 
                 writeln!(f, "Http status indicates failure: {:?}", response),
         }
@@ -280,7 +310,7 @@ impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::HttpError(ref err) => err.description(),
-            Error::JsonDecodeError(ref err) => err.description(),
+            Error::JsonDecodeError(_, ref err) => err.description(),
             _ => "NO DESCRIPTION POSSIBLE - use `Display.fmt()` instead"
         }
     }
@@ -288,7 +318,7 @@ impl error::Error for Error {
     fn cause(&self) -> Option<&error::Error> {
         match *self {
             Error::HttpError(ref err) => err.cause(),
-            Error::JsonDecodeError(ref err) => err.cause(),
+            Error::JsonDecodeError(_, ref err) => err.cause(),
             _ => None
         }
     }
@@ -401,7 +431,7 @@ 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;
@@ -489,7 +519,7 @@ impl Header for ContentRange {
 
 impl HeaderFormat for ContentRange {
     fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        try!(fmt.write_str("bytes="));
+        try!(fmt.write_str("bytes "));
         match self.range {
             Some(ref c) => try!(c.fmt(fmt)),
             None => try!(fmt.write_str("*"))
@@ -510,7 +540,7 @@ impl Header for RangeResponseHeader {
     fn parse_header(raw: &[Vec<u8>]) -> Option<RangeResponseHeader> {
         if let [ref v] = raw {
             if let Ok(s) = std::str::from_utf8(v) {
-                const PREFIX: &'static str = "bytes=";
+                const PREFIX: &'static str = "bytes ";
                 if s.starts_with(PREFIX) {
                     if let Ok(c) = <Chunk as FromStr>::from_str(&s[PREFIX.len()..]) {
                         return  Some(RangeResponseHeader(c))
@@ -559,7 +589,7 @@ impl<'a, A> ResumableUploadHelper<'a, A>
                     let h: &RangeResponseHeader = match headers.get() {
                         Some(hh) if r.status == StatusCode::PermanentRedirect => hh,
                         None|Some(_) => {
-                            if let Retry::After(d) = self.delegate.http_failure(&r, None) {
+                            if let Retry::After(d) = self.delegate.http_failure(&r, None, None) {
                                 sleep_ms(d.num_milliseconds() as u32);
                                 continue;
                             }
@@ -626,7 +656,9 @@ impl<'a, A> ResumableUploadHelper<'a, A>
                     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, serde::json::from_str(&json_err).ok()) {
+                        if let Retry::After(d) = self.delegate.http_failure(&res, 
+                                                        serde::json::from_str(&json_err).ok(),
+                                                        serde::json::from_str(&json_err).ok()) {
                             sleep_ms(d.num_milliseconds() as u32);
                             continue;
                         }