diff --git a/gen/youtube3/src/lib.rs b/gen/youtube3/src/lib.rs index 02bec034da4..44482e8e112 100644 --- a/gen/youtube3/src/lib.rs +++ b/gen/youtube3/src/lib.rs @@ -6684,6 +6684,7 @@ impl<'a, C, NC, A> I18nLanguageListMethodBuilder<'a, C, NC, A> where NC: hyper:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -6695,12 +6696,11 @@ impl<'a, C, NC, A> I18nLanguageListMethodBuilder<'a, C, NC, A> where NC: hyper:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.i18nLanguages.list"), None => {} @@ -6875,7 +6875,7 @@ impl<'a, C, NC, A> ChannelBannerInsertMethodBuilder<'a, C, NC, A> where NC: hype /// Perform the operation you have build so far. - fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, ChannelBannerResource)> where R: io::Read, RS: ReadSeek { + fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, ChannelBannerResource)> where R: ReadSeek, RS: ReadSeek { use hyper::client::IntoBody; use std::io::{Read, Seek}; let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len()); @@ -6910,7 +6910,9 @@ impl<'a, C, NC, A> ChannelBannerInsertMethodBuilder<'a, C, NC, A> where NC: hype } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -6921,27 +6923,26 @@ impl<'a, C, NC, A> ChannelBannerInsertMethodBuilder<'a, C, NC, A> where NC: hype } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) - .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) - .header(auth_header); + let mut request_value_reader = io::Cursor::new(json_encoded_request.clone().into_bytes()); let mut mp_reader: cmn::MultiPartReader = Default::default(); - let mut request_value_reader = io::Cursor::new(json_encoded_request.into_bytes()); - let mut content_type = hyper::header::ContentType(json_mime_type); + let mut content_type = hyper::header::ContentType(json_mime_type.clone()); let mut body_reader: &mut io::Read = match stream.as_mut() { Some(&mut (ref mut reader, size, ref mime)) => { let rsize = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); - request_value_reader.seek(io::SeekFrom::Start(0)); + request_value_reader.seek(io::SeekFrom::Start(0)).ok(); mp_reader = mp_reader.add_part(&mut request_value_reader, rsize, &json_mime_type) .add_part(reader, size, mime); &mut mp_reader } None => &mut request_value_reader, }; - req = req.header(content_type).body(body_reader.into_body()); - + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) + .header(auth_header) + .header(content_type) + .body(body_reader.into_body()); match self._delegate { Some(ref mut d) => d.pre_request("youtube.channelBanners.insert"), @@ -6987,7 +6988,7 @@ impl<'a, C, NC, A> ChannelBannerInsertMethodBuilder<'a, C, NC, A> where NC: hype /// * *multipart*: yes /// * *valid mime types*: 'application/octet-stream', 'image/jpeg' and 'image/png' pub fn upload(self, stream: R, size: u64, mime_type: mime::Mime) -> cmn::Result<(hyper::client::Response, ChannelBannerResource)> - where R: io::Read { + where R: ReadSeek { self.doit(Some((stream, size, mime_type)), None::<(fs::File, u64, mime::Mime)>, ) } /// Upload media in a resumeable fashion. @@ -7184,6 +7185,7 @@ impl<'a, C, NC, A> ChannelSectionListMethodBuilder<'a, C, NC, A> where NC: hyper } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -7195,12 +7197,11 @@ impl<'a, C, NC, A> ChannelSectionListMethodBuilder<'a, C, NC, A> where NC: hyper let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channelSections.list"), None => {} @@ -7452,7 +7453,9 @@ impl<'a, C, NC, A> ChannelSectionInsertMethodBuilder<'a, C, NC, A> where NC: hyp } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -7463,16 +7466,15 @@ impl<'a, C, NC, A> ChannelSectionInsertMethodBuilder<'a, C, NC, A> where NC: hyp } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channelSections.insert"), None => {} @@ -7698,6 +7700,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteMethodBuilder<'a, C, NC, A> where NC: hyp } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -7709,12 +7712,11 @@ impl<'a, C, NC, A> ChannelSectionDeleteMethodBuilder<'a, C, NC, A> where NC: hyp let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channelSections.delete"), None => {} @@ -7927,7 +7929,9 @@ impl<'a, C, NC, A> ChannelSectionUpdateMethodBuilder<'a, C, NC, A> where NC: hyp } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -7938,16 +7942,15 @@ impl<'a, C, NC, A> ChannelSectionUpdateMethodBuilder<'a, C, NC, A> where NC: hyp } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channelSections.update"), None => {} @@ -8185,6 +8188,7 @@ impl<'a, C, NC, A> GuideCategoryListMethodBuilder<'a, C, NC, A> where NC: hyper: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -8196,12 +8200,11 @@ impl<'a, C, NC, A> GuideCategoryListMethodBuilder<'a, C, NC, A> where NC: hyper: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.guideCategories.list"), None => {} @@ -8442,7 +8445,9 @@ impl<'a, C, NC, A> PlaylistInsertMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -8453,16 +8458,15 @@ impl<'a, C, NC, A> PlaylistInsertMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlists.insert"), None => {} @@ -8734,6 +8738,7 @@ impl<'a, C, NC, A> PlaylistListMethodBuilder<'a, C, NC, A> where NC: hyper::net: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -8745,12 +8750,11 @@ impl<'a, C, NC, A> PlaylistListMethodBuilder<'a, C, NC, A> where NC: hyper::net: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlists.list"), None => {} @@ -9001,6 +9005,7 @@ impl<'a, C, NC, A> PlaylistDeleteMethodBuilder<'a, C, NC, A> where NC: hyper::ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -9012,12 +9017,11 @@ impl<'a, C, NC, A> PlaylistDeleteMethodBuilder<'a, C, NC, A> where NC: hyper::ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlists.delete"), None => {} @@ -9230,7 +9234,9 @@ impl<'a, C, NC, A> PlaylistUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -9241,16 +9247,15 @@ impl<'a, C, NC, A> PlaylistUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlists.update"), None => {} @@ -9438,7 +9443,7 @@ impl<'a, C, NC, A> ThumbnailSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: /// Perform the operation you have build so far. - fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, ThumbnailSetResponse)> where R: io::Read, RS: ReadSeek { + fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, ThumbnailSetResponse)> where R: ReadSeek, RS: ReadSeek { use hyper::client::IntoBody; use std::io::{Read, Seek}; let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len()); @@ -9474,6 +9479,7 @@ impl<'a, C, NC, A> ThumbnailSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -9484,16 +9490,16 @@ impl<'a, C, NC, A> ThumbnailSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - if let Some(&mut (ref mut reader, size, ref mime)) = stream.as_mut() { - req = req.header(hyper::header::ContentType(mime.clone())).body(reader.into_body()); + req = req.header(hyper::header::ContentType(mime.clone())) + .header(hyper::header::ContentLength(size)) + .body(reader.into_body()); } - match self._delegate { Some(ref mut d) => d.pre_request("youtube.thumbnails.set"), @@ -9539,7 +9545,7 @@ impl<'a, C, NC, A> ThumbnailSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: /// * *multipart*: yes /// * *valid mime types*: 'application/octet-stream', 'image/jpeg' and 'image/png' pub fn upload(self, stream: R, size: u64, mime_type: mime::Mime) -> cmn::Result<(hyper::client::Response, ThumbnailSetResponse)> - where R: io::Read { + where R: ReadSeek { self.doit(Some((stream, size, mime_type)), None::<(fs::File, u64, mime::Mime)>, ) } /// Upload media in a resumeable fashion. @@ -9775,6 +9781,7 @@ impl<'a, C, NC, A> VideoListMethodBuilder<'a, C, NC, A> where NC: hyper::net::Ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -9786,12 +9793,11 @@ impl<'a, C, NC, A> VideoListMethodBuilder<'a, C, NC, A> where NC: hyper::net::Ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.list"), None => {} @@ -10077,6 +10083,7 @@ impl<'a, C, NC, A> VideoRateMethodBuilder<'a, C, NC, A> where NC: hyper::net::Ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -10088,12 +10095,11 @@ impl<'a, C, NC, A> VideoRateMethodBuilder<'a, C, NC, A> where NC: hyper::net::Ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.rate"), None => {} @@ -10291,6 +10297,7 @@ impl<'a, C, NC, A> VideoGetRatingMethodBuilder<'a, C, NC, A> where NC: hyper::ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -10302,12 +10309,11 @@ impl<'a, C, NC, A> VideoGetRatingMethodBuilder<'a, C, NC, A> where NC: hyper::ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.getRating"), None => {} @@ -10497,6 +10503,7 @@ impl<'a, C, NC, A> VideoDeleteMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -10508,12 +10515,11 @@ impl<'a, C, NC, A> VideoDeleteMethodBuilder<'a, C, NC, A> where NC: hyper::net:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.delete"), None => {} @@ -10746,7 +10752,9 @@ impl<'a, C, NC, A> VideoUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -10757,16 +10765,15 @@ impl<'a, C, NC, A> VideoUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.update"), None => {} @@ -11027,7 +11034,7 @@ impl<'a, C, NC, A> VideoInsertMethodBuilder<'a, C, NC, A> where NC: hyper::net:: /// Perform the operation you have build so far. - fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, Video)> where R: io::Read, RS: ReadSeek { + fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result<(hyper::client::Response, Video)> where R: ReadSeek, RS: ReadSeek { use hyper::client::IntoBody; use std::io::{Read, Seek}; let mut params: Vec<(&str, String)> = Vec::with_capacity(8 + self._additional_params.len()); @@ -11078,7 +11085,9 @@ impl<'a, C, NC, A> VideoInsertMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -11089,27 +11098,26 @@ impl<'a, C, NC, A> VideoInsertMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) - .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) - .header(auth_header); + let mut request_value_reader = io::Cursor::new(json_encoded_request.clone().into_bytes()); let mut mp_reader: cmn::MultiPartReader = Default::default(); - let mut request_value_reader = io::Cursor::new(json_encoded_request.into_bytes()); - let mut content_type = hyper::header::ContentType(json_mime_type); + let mut content_type = hyper::header::ContentType(json_mime_type.clone()); let mut body_reader: &mut io::Read = match stream.as_mut() { Some(&mut (ref mut reader, size, ref mime)) => { let rsize = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); - request_value_reader.seek(io::SeekFrom::Start(0)); + request_value_reader.seek(io::SeekFrom::Start(0)).ok(); mp_reader = mp_reader.add_part(&mut request_value_reader, rsize, &json_mime_type) .add_part(reader, size, mime); &mut mp_reader } None => &mut request_value_reader, }; - req = req.header(content_type).body(body_reader.into_body()); - + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) + .header(auth_header) + .header(content_type) + .body(body_reader.into_body()); match self._delegate { Some(ref mut d) => d.pre_request("youtube.videos.insert"), @@ -11155,7 +11163,7 @@ impl<'a, C, NC, A> VideoInsertMethodBuilder<'a, C, NC, A> where NC: hyper::net:: /// * *multipart*: yes /// * *valid mime types*: 'application/octet-stream' and 'video/*' pub fn upload(self, stream: R, size: u64, mime_type: mime::Mime) -> cmn::Result<(hyper::client::Response, Video)> - where R: io::Read { + where R: ReadSeek { self.doit(Some((stream, size, mime_type)), None::<(fs::File, u64, mime::Mime)>, ) } /// Upload media in a resumeable fashion. @@ -11423,7 +11431,9 @@ impl<'a, C, NC, A> SubscriptionInsertMethodBuilder<'a, C, NC, A> where NC: hyper } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -11434,16 +11444,15 @@ impl<'a, C, NC, A> SubscriptionInsertMethodBuilder<'a, C, NC, A> where NC: hyper } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.subscriptions.insert"), None => {} @@ -11707,6 +11716,7 @@ impl<'a, C, NC, A> SubscriptionListMethodBuilder<'a, C, NC, A> where NC: hyper:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -11718,12 +11728,11 @@ impl<'a, C, NC, A> SubscriptionListMethodBuilder<'a, C, NC, A> where NC: hyper:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.subscriptions.list"), None => {} @@ -11992,6 +12001,7 @@ impl<'a, C, NC, A> SubscriptionDeleteMethodBuilder<'a, C, NC, A> where NC: hyper } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -12003,12 +12013,11 @@ impl<'a, C, NC, A> SubscriptionDeleteMethodBuilder<'a, C, NC, A> where NC: hyper let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.subscriptions.delete"), None => {} @@ -12340,6 +12349,7 @@ impl<'a, C, NC, A> SearchListMethodBuilder<'a, C, NC, A> where NC: hyper::net::N } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -12351,12 +12361,11 @@ impl<'a, C, NC, A> SearchListMethodBuilder<'a, C, NC, A> where NC: hyper::net::N let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.search.list"), None => {} @@ -12793,6 +12802,7 @@ impl<'a, C, NC, A> I18nRegionListMethodBuilder<'a, C, NC, A> where NC: hyper::ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -12804,12 +12814,11 @@ impl<'a, C, NC, A> I18nRegionListMethodBuilder<'a, C, NC, A> where NC: hyper::ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.i18nRegions.list"), None => {} @@ -13035,7 +13044,9 @@ impl<'a, C, NC, A> LiveStreamUpdateMethodBuilder<'a, C, NC, A> where NC: hyper:: } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -13046,16 +13057,15 @@ impl<'a, C, NC, A> LiveStreamUpdateMethodBuilder<'a, C, NC, A> where NC: hyper:: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveStreams.update"), None => {} @@ -13292,6 +13302,7 @@ impl<'a, C, NC, A> LiveStreamDeleteMethodBuilder<'a, C, NC, A> where NC: hyper:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -13303,12 +13314,11 @@ impl<'a, C, NC, A> LiveStreamDeleteMethodBuilder<'a, C, NC, A> where NC: hyper:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveStreams.delete"), None => {} @@ -13548,6 +13558,7 @@ impl<'a, C, NC, A> LiveStreamListMethodBuilder<'a, C, NC, A> where NC: hyper::ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -13559,12 +13570,11 @@ impl<'a, C, NC, A> LiveStreamListMethodBuilder<'a, C, NC, A> where NC: hyper::ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveStreams.list"), None => {} @@ -13838,7 +13848,9 @@ impl<'a, C, NC, A> LiveStreamInsertMethodBuilder<'a, C, NC, A> where NC: hyper:: } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -13849,16 +13861,15 @@ impl<'a, C, NC, A> LiveStreamInsertMethodBuilder<'a, C, NC, A> where NC: hyper:: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveStreams.insert"), None => {} @@ -14113,7 +14124,9 @@ impl<'a, C, NC, A> ChannelUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::net } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -14124,16 +14137,15 @@ impl<'a, C, NC, A> ChannelUpdateMethodBuilder<'a, C, NC, A> where NC: hyper::net } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channels.update"), None => {} @@ -14406,6 +14418,7 @@ impl<'a, C, NC, A> ChannelListMethodBuilder<'a, C, NC, A> where NC: hyper::net:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -14417,12 +14430,11 @@ impl<'a, C, NC, A> ChannelListMethodBuilder<'a, C, NC, A> where NC: hyper::net:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.channels.list"), None => {} @@ -14680,6 +14692,7 @@ impl<'a, C, NC, A> PlaylistItemDeleteMethodBuilder<'a, C, NC, A> where NC: hyper } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -14691,12 +14704,11 @@ impl<'a, C, NC, A> PlaylistItemDeleteMethodBuilder<'a, C, NC, A> where NC: hyper let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlistItems.delete"), None => {} @@ -14915,6 +14927,7 @@ impl<'a, C, NC, A> PlaylistItemListMethodBuilder<'a, C, NC, A> where NC: hyper:: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -14926,12 +14939,11 @@ impl<'a, C, NC, A> PlaylistItemListMethodBuilder<'a, C, NC, A> where NC: hyper:: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlistItems.list"), None => {} @@ -15197,7 +15209,9 @@ impl<'a, C, NC, A> PlaylistItemInsertMethodBuilder<'a, C, NC, A> where NC: hyper } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -15208,16 +15222,15 @@ impl<'a, C, NC, A> PlaylistItemInsertMethodBuilder<'a, C, NC, A> where NC: hyper } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlistItems.insert"), None => {} @@ -15455,7 +15468,9 @@ impl<'a, C, NC, A> PlaylistItemUpdateMethodBuilder<'a, C, NC, A> where NC: hyper } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -15466,16 +15481,15 @@ impl<'a, C, NC, A> PlaylistItemUpdateMethodBuilder<'a, C, NC, A> where NC: hyper } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.playlistItems.update"), None => {} @@ -15662,7 +15676,7 @@ impl<'a, C, NC, A> WatermarkSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: /// Perform the operation you have build so far. - fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result where R: io::Read, RS: ReadSeek { + fn doit(mut self, mut stream: Option<(R, u64, mime::Mime)>, mut resumeable_stream: Option<(RS, u64, mime::Mime)>) -> cmn::Result where R: ReadSeek, RS: ReadSeek { use hyper::client::IntoBody; use std::io::{Read, Seek}; let mut params: Vec<(&str, String)> = Vec::with_capacity(4 + self._additional_params.len()); @@ -15698,7 +15712,9 @@ impl<'a, C, NC, A> WatermarkSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -15709,27 +15725,26 @@ impl<'a, C, NC, A> WatermarkSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) - .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) - .header(auth_header); + let mut request_value_reader = io::Cursor::new(json_encoded_request.clone().into_bytes()); let mut mp_reader: cmn::MultiPartReader = Default::default(); - let mut request_value_reader = io::Cursor::new(json_encoded_request.into_bytes()); - let mut content_type = hyper::header::ContentType(json_mime_type); + let mut content_type = hyper::header::ContentType(json_mime_type.clone()); let mut body_reader: &mut io::Read = match stream.as_mut() { Some(&mut (ref mut reader, size, ref mime)) => { let rsize = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); - request_value_reader.seek(io::SeekFrom::Start(0)); + request_value_reader.seek(io::SeekFrom::Start(0)).ok(); mp_reader = mp_reader.add_part(&mut request_value_reader, rsize, &json_mime_type) .add_part(reader, size, mime); &mut mp_reader } None => &mut request_value_reader, }; - req = req.header(content_type).body(body_reader.into_body()); - + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) + .header(auth_header) + .header(content_type) + .body(body_reader.into_body()); match self._delegate { Some(ref mut d) => d.pre_request("youtube.watermarks.set"), @@ -15773,7 +15788,7 @@ impl<'a, C, NC, A> WatermarkSetMethodBuilder<'a, C, NC, A> where NC: hyper::net: /// * *multipart*: yes /// * *valid mime types*: 'application/octet-stream', 'image/jpeg' and 'image/png' pub fn upload(self, stream: R, size: u64, mime_type: mime::Mime) -> cmn::Result - where R: io::Read { + where R: ReadSeek { self.doit(Some((stream, size, mime_type)), None::<(fs::File, u64, mime::Mime)>, ) } /// Upload media in a resumeable fashion. @@ -15948,6 +15963,7 @@ impl<'a, C, NC, A> WatermarkUnsetMethodBuilder<'a, C, NC, A> where NC: hyper::ne } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -15959,12 +15975,11 @@ impl<'a, C, NC, A> WatermarkUnsetMethodBuilder<'a, C, NC, A> where NC: hyper::ne let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.watermarks.unset"), None => {} @@ -16186,6 +16201,7 @@ impl<'a, C, NC, A> LiveBroadcastControlMethodBuilder<'a, C, NC, A> where NC: hyp } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -16197,12 +16213,11 @@ impl<'a, C, NC, A> LiveBroadcastControlMethodBuilder<'a, C, NC, A> where NC: hyp let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.control"), None => {} @@ -16482,7 +16497,9 @@ impl<'a, C, NC, A> LiveBroadcastUpdateMethodBuilder<'a, C, NC, A> where NC: hype } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -16493,16 +16510,15 @@ impl<'a, C, NC, A> LiveBroadcastUpdateMethodBuilder<'a, C, NC, A> where NC: hype } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("PUT".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.update"), None => {} @@ -16767,7 +16783,9 @@ impl<'a, C, NC, A> LiveBroadcastInsertMethodBuilder<'a, C, NC, A> where NC: hype } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -16778,16 +16796,15 @@ impl<'a, C, NC, A> LiveBroadcastInsertMethodBuilder<'a, C, NC, A> where NC: hype } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.insert"), None => {} @@ -17043,6 +17060,7 @@ impl<'a, C, NC, A> LiveBroadcastBindMethodBuilder<'a, C, NC, A> where NC: hyper: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -17054,12 +17072,11 @@ impl<'a, C, NC, A> LiveBroadcastBindMethodBuilder<'a, C, NC, A> where NC: hyper: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.bind"), None => {} @@ -17331,6 +17348,7 @@ impl<'a, C, NC, A> LiveBroadcastListMethodBuilder<'a, C, NC, A> where NC: hyper: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -17342,12 +17360,11 @@ impl<'a, C, NC, A> LiveBroadcastListMethodBuilder<'a, C, NC, A> where NC: hyper: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.list"), None => {} @@ -17601,6 +17618,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteMethodBuilder<'a, C, NC, A> where NC: hype } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -17612,12 +17630,11 @@ impl<'a, C, NC, A> LiveBroadcastDeleteMethodBuilder<'a, C, NC, A> where NC: hype let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("DELETE".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.delete"), None => {} @@ -17840,6 +17857,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionMethodBuilder<'a, C, NC, A> where NC: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -17851,12 +17869,11 @@ impl<'a, C, NC, A> LiveBroadcastTransitionMethodBuilder<'a, C, NC, A> where NC: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.liveBroadcasts.transition"), None => {} @@ -18109,6 +18126,7 @@ impl<'a, C, NC, A> VideoCategoryListMethodBuilder<'a, C, NC, A> where NC: hyper: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -18120,12 +18138,11 @@ impl<'a, C, NC, A> VideoCategoryListMethodBuilder<'a, C, NC, A> where NC: hyper: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.videoCategories.list"), None => {} @@ -18383,6 +18400,7 @@ impl<'a, C, NC, A> ActivityListMethodBuilder<'a, C, NC, A> where NC: hyper::net: } + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -18394,12 +18412,11 @@ impl<'a, C, NC, A> ActivityListMethodBuilder<'a, C, NC, A> where NC: hyper::net: let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("GET".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.activities.list"), None => {} @@ -18672,7 +18689,9 @@ impl<'a, C, NC, A> ActivityInsertMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let json_encoded_request = json::encode(&self._request).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); + let mut client = &mut *self.hub.client.borrow_mut(); loop { let mut token = self.hub.auth.borrow_mut().token(self._scopes.keys()); if token.is_none() && self._delegate.is_some() { @@ -18683,16 +18702,15 @@ impl<'a, C, NC, A> ActivityInsertMethodBuilder<'a, C, NC, A> where NC: hyper::ne } let auth_header = hyper::header::Authorization(token.unwrap().access_token); - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - let mut req = (*self.hub.client.borrow_mut()).borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("POST".to_string()), url.as_slice()) .header(hyper::header::UserAgent("google-api-rust-client/0.0.1".to_string())) .header(auth_header) - .header(hyper::header::ContentType(json_mime_type)) + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) .body(json_encoded_request.as_slice()); - - match self._delegate { Some(ref mut d) => d.pre_request("youtube.activities.insert"), None => {} diff --git a/src/mako/lib/mbuild.mako b/src/mako/lib/mbuild.mako index 505cacc3d0f..3aad95c6468 100644 --- a/src/mako/lib/mbuild.mako +++ b/src/mako/lib/mbuild.mako @@ -400,7 +400,6 @@ match result { delegate = 'self.' + property(DELEGATE_PROPERTY_NAME) delegate_call = delegate + '.as_mut().unwrap()' auth_call = 'self.hub.auth.borrow_mut()' - client = '(*self.hub.client.borrow_mut()).borrow_mut()' if supports_scopes(auth): all_scopes = sorted(auth.oauth2.scopes.keys()) @@ -590,10 +589,11 @@ else { % if request_value: let json_encoded_request = json::encode(&self.${property(REQUEST_VALUE_PROPERTY_NAME)}).unwrap(); + let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); % endif + let mut client = &mut *self.hub.client.borrow_mut(); loop { - ## TODO: Need to Seek as we are in a loop here ... % if supports_scopes(auth): let mut token = ${auth_call}.token(self.${api.properties.scopes}.keys()); if token.is_none() && ${delegate}.is_some() { @@ -605,31 +605,15 @@ else { let auth_header = hyper::header::Authorization(token.unwrap().access_token); % endif - % if request_value or simple_media_param: - let mut json_mime_type = mime::Mime(mime::TopLevel::Application, mime::SubLevel::Json, Default::default()); - % endif - - let mut req = ${client}.request(hyper::method::Method::Extension("${m.httpMethod}".to_string()), url.as_slice()) - .header(hyper::header::UserAgent("google-api-rust-client/${cargo.build_version}".to_string()))\ - % if supports_scopes(auth): - - .header(auth_header)\ - % endif - % if request_value and not simple_media_param: - - .header(hyper::header::ContentType(json_mime_type)) - .body(json_encoded_request.as_slice())\ - % endif -; % if request_value and simple_media_param: + let mut request_value_reader = io::Cursor::new(json_encoded_request.clone().into_bytes()); let mut mp_reader: cmn::MultiPartReader = Default::default(); - let mut request_value_reader = io::Cursor::new(json_encoded_request.into_bytes()); - let mut content_type = hyper::header::ContentType(json_mime_type); + let mut content_type = hyper::header::ContentType(json_mime_type.clone()); let mut body_reader: &mut io::Read = match ${simple_media_param.type.arg_name}.as_mut() { Some(&mut (ref mut reader, size, ref mime)) => { let rsize = request_value_reader.seek(io::SeekFrom::End(0)).unwrap(); - request_value_reader.seek(io::SeekFrom::Start(0)); + request_value_reader.seek(io::SeekFrom::Start(0)).ok(); mp_reader = mp_reader.add_part(&mut request_value_reader, rsize, &json_mime_type) .add_part(reader, size, mime); ## TODO: content_type = multi-part @@ -637,13 +621,34 @@ else { } None => &mut request_value_reader, }; - req = req.header(content_type).body(body_reader.into_body()); - % elif simple_media_param: + % endif + + let mut req = client.borrow_mut().request(hyper::method::Method::Extension("${m.httpMethod}".to_string()), url.as_slice()) + .header(hyper::header::UserAgent("google-api-rust-client/${cargo.build_version}".to_string()))\ + % if supports_scopes(auth): + + .header(auth_header)\ + % endif + % if request_value: + % if not simple_media_param: + + .header(hyper::header::ContentType(json_mime_type.clone())) + .header(hyper::header::ContentLength(json_encoded_request.len() as u64)) + .body(json_encoded_request.as_slice())\ + % else: + + .header(content_type) + .body(body_reader.into_body())\ + % endif ## not simple_media_param + % endif +; + % if simple_media_param and not request_value: if let Some(&mut (ref mut reader, size, ref mime)) = ${simple_media_param.type.arg_name}.as_mut() { - req = req.header(hyper::header::ContentType(mime.clone())).body(reader.into_body()); + req = req.header(hyper::header::ContentType(mime.clone())) + .header(hyper::header::ContentLength(size)) + .body(reader.into_body()); } % endif ## media upload handling - match ${delegate} { Some(ref mut d) => d.pre_request("${m.id}"), diff --git a/src/mako/lib/util.py b/src/mako/lib/util.py index 430e29d5edb..da96336900b 100644 --- a/src/mako/lib/util.py +++ b/src/mako/lib/util.py @@ -75,7 +75,7 @@ 'description': """Upload media all at once. If the upload fails for whichever reason, all progress is lost.""", 'default': 'fs::File', - 'where': 'io::Read', + 'where': 'ReadSeek', 'suffix': '', 'example_value': 'fs::File::open("file.ext").unwrap(), 148, "application/octet-stream".parse().unwrap()' },