mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-01-01 17:14:19 +01:00
4218 lines
179 KiB
Rust
4218 lines
179 KiB
Rust
use std::collections::HashMap;
|
||
use std::cell::RefCell;
|
||
use std::default::Default;
|
||
use std::collections::BTreeSet;
|
||
use std::error::Error as StdError;
|
||
use serde_json as json;
|
||
use std::io;
|
||
use std::fs;
|
||
use std::mem;
|
||
|
||
use hyper::client::connect;
|
||
use tokio::io::{AsyncRead, AsyncWrite};
|
||
use tokio::time::sleep;
|
||
use tower_service;
|
||
use serde::{Serialize, Deserialize};
|
||
|
||
use crate::{client, client::GetToken, client::serde_with};
|
||
|
||
// ##############
|
||
// UTILITIES ###
|
||
// ############
|
||
|
||
/// Identifies the an OAuth2 authorization scope.
|
||
/// A scope is needed when requesting an
|
||
/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication).
|
||
#[derive(PartialEq, Eq, Ord, PartialOrd, Hash, Debug, Clone, Copy)]
|
||
pub enum Scope {
|
||
/// See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
|
||
CloudPlatform,
|
||
}
|
||
|
||
impl AsRef<str> for Scope {
|
||
fn as_ref(&self) -> &str {
|
||
match *self {
|
||
Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for Scope {
|
||
fn default() -> Scope {
|
||
Scope::CloudPlatform
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// ########
|
||
// HUB ###
|
||
// ######
|
||
|
||
/// Central instance to access all Transcoder related resource activities
|
||
///
|
||
/// # Examples
|
||
///
|
||
/// Instantiate a new hub
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_transcoder1 as transcoder1;
|
||
/// use transcoder1::api::Job;
|
||
/// use transcoder1::{Result, Error};
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
|
||
/// // `client_secret`, among other things.
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
|
||
/// // unless you replace `None` with the desired Flow.
|
||
/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
|
||
/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
|
||
/// // retrieve them from storage.
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = Job::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_jobs_create(req, "parent")
|
||
/// .doit().await;
|
||
///
|
||
/// match result {
|
||
/// Err(e) => match e {
|
||
/// // The Error enum provides details about what exactly happened.
|
||
/// // You can also just use its `Debug`, `Display` or `Error` traits
|
||
/// Error::HttpError(_)
|
||
/// |Error::Io(_)
|
||
/// |Error::MissingAPIKey
|
||
/// |Error::MissingToken(_)
|
||
/// |Error::Cancelled
|
||
/// |Error::UploadSizeLimitExceeded(_, _)
|
||
/// |Error::Failure(_)
|
||
/// |Error::BadRequest(_)
|
||
/// |Error::FieldClash(_)
|
||
/// |Error::JsonDecodeError(_, _) => println!("{}", e),
|
||
/// },
|
||
/// Ok(res) => println!("Success: {:?}", res),
|
||
/// }
|
||
/// # }
|
||
/// ```
|
||
#[derive(Clone)]
|
||
pub struct Transcoder<S> {
|
||
pub client: hyper::Client<S, hyper::body::Body>,
|
||
pub auth: Box<dyn client::GetToken>,
|
||
_user_agent: String,
|
||
_base_url: String,
|
||
_root_url: String,
|
||
}
|
||
|
||
impl<'a, S> client::Hub for Transcoder<S> {}
|
||
|
||
impl<'a, S> Transcoder<S> {
|
||
|
||
pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> Transcoder<S> {
|
||
Transcoder {
|
||
client,
|
||
auth: Box::new(auth),
|
||
_user_agent: "google-api-rust-client/5.0.4".to_string(),
|
||
_base_url: "https://transcoder.googleapis.com/".to_string(),
|
||
_root_url: "https://transcoder.googleapis.com/".to_string(),
|
||
}
|
||
}
|
||
|
||
pub fn projects(&'a self) -> ProjectMethods<'a, S> {
|
||
ProjectMethods { hub: &self }
|
||
}
|
||
|
||
/// Set the user-agent header field to use in all requests to the server.
|
||
/// It defaults to `google-api-rust-client/5.0.4`.
|
||
///
|
||
/// Returns the previously set user-agent.
|
||
pub fn user_agent(&mut self, agent_name: String) -> String {
|
||
mem::replace(&mut self._user_agent, agent_name)
|
||
}
|
||
|
||
/// Set the base url to use in all requests to the server.
|
||
/// It defaults to `https://transcoder.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set base url.
|
||
pub fn base_url(&mut self, new_base_url: String) -> String {
|
||
mem::replace(&mut self._base_url, new_base_url)
|
||
}
|
||
|
||
/// Set the root url to use in all requests to the server.
|
||
/// It defaults to `https://transcoder.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set root url.
|
||
pub fn root_url(&mut self, new_root_url: String) -> String {
|
||
mem::replace(&mut self._root_url, new_root_url)
|
||
}
|
||
}
|
||
|
||
|
||
// ############
|
||
// SCHEMAS ###
|
||
// ##########
|
||
/// Ad break.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AdBreak {
|
||
/// Start time in seconds for the ad break, relative to the output file timeline. The default is `0s`.
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
}
|
||
|
||
impl client::Part for AdBreak {}
|
||
|
||
|
||
/// Configuration for AES-128 encryption.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Aes128Encryption { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Aes128Encryption {}
|
||
|
||
|
||
/// Animation types.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Animation {
|
||
/// End previous animation.
|
||
#[serde(rename="animationEnd")]
|
||
|
||
pub animation_end: Option<AnimationEnd>,
|
||
/// Display overlay object with fade animation.
|
||
#[serde(rename="animationFade")]
|
||
|
||
pub animation_fade: Option<AnimationFade>,
|
||
/// Display static overlay object.
|
||
#[serde(rename="animationStatic")]
|
||
|
||
pub animation_static: Option<AnimationStatic>,
|
||
}
|
||
|
||
impl client::Part for Animation {}
|
||
|
||
|
||
/// End previous overlay animation from the video. Without `AnimationEnd`, the overlay object will keep the state of previous animation until the end of the video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AnimationEnd {
|
||
/// The time to end overlay object, in seconds. Default: 0
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
}
|
||
|
||
impl client::Part for AnimationEnd {}
|
||
|
||
|
||
/// Display overlay object with fade animation.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AnimationFade {
|
||
/// The time to end the fade animation, in seconds. Default: `start_time_offset` + 1s
|
||
#[serde(rename="endTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub end_time_offset: Option<client::chrono::Duration>,
|
||
/// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
|
||
#[serde(rename="fadeType")]
|
||
|
||
pub fade_type: Option<String>,
|
||
/// The time to start the fade animation, in seconds. Default: 0
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
/// Normalized coordinates based on output video resolution. Valid values: `0.0`–`1.0`. `xy` is the upper-left coordinate of the overlay object. For example, use the x and y coordinates {0,0} to position the top-left corner of the overlay animation in the top-left corner of the output video.
|
||
|
||
pub xy: Option<NormalizedCoordinate>,
|
||
}
|
||
|
||
impl client::Part for AnimationFade {}
|
||
|
||
|
||
/// Display static overlay object.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AnimationStatic {
|
||
/// The time to start displaying the overlay object, in seconds. Default: 0
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
/// Normalized coordinates based on output video resolution. Valid values: `0.0`–`1.0`. `xy` is the upper-left coordinate of the overlay object. For example, use the x and y coordinates {0,0} to position the top-left corner of the overlay animation in the top-left corner of the output video.
|
||
|
||
pub xy: Option<NormalizedCoordinate>,
|
||
}
|
||
|
||
impl client::Part for AnimationStatic {}
|
||
|
||
|
||
/// Audio preprocessing configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Audio {
|
||
/// Enable boosting high frequency components. The default is `false`. **Note:** This field is not supported.
|
||
#[serde(rename="highBoost")]
|
||
|
||
pub high_boost: Option<bool>,
|
||
/// Enable boosting low frequency components. The default is `false`. **Note:** This field is not supported.
|
||
#[serde(rename="lowBoost")]
|
||
|
||
pub low_boost: Option<bool>,
|
||
/// Specify audio loudness normalization in loudness units relative to full scale (LUFS). Enter a value between -24 and 0 (the default), where: * -24 is the Advanced Television Systems Committee (ATSC A/85) standard * -23 is the EU R128 broadcast standard * -19 is the prior standard for online mono audio * -18 is the ReplayGain standard * -16 is the prior standard for stereo audio * -14 is the new online audio standard recommended by Spotify, as well as Amazon Echo * 0 disables normalization
|
||
|
||
pub lufs: Option<f64>,
|
||
}
|
||
|
||
impl client::Part for Audio {}
|
||
|
||
|
||
/// The mapping for the JobConfig.edit_list atoms with audio EditAtom.inputs.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AudioMapping {
|
||
/// Required. The EditAtom.key that references the atom with audio inputs in the JobConfig.edit_list.
|
||
#[serde(rename="atomKey")]
|
||
|
||
pub atom_key: Option<String>,
|
||
/// Audio volume control in dB. Negative values decrease volume, positive values increase. The default is 0.
|
||
#[serde(rename="gainDb")]
|
||
|
||
pub gain_db: Option<f64>,
|
||
/// Required. The zero-based index of the channel in the input audio stream.
|
||
#[serde(rename="inputChannel")]
|
||
|
||
pub input_channel: Option<i32>,
|
||
/// Required. The Input.key that identifies the input file.
|
||
#[serde(rename="inputKey")]
|
||
|
||
pub input_key: Option<String>,
|
||
/// Required. The zero-based index of the track in the input file.
|
||
#[serde(rename="inputTrack")]
|
||
|
||
pub input_track: Option<i32>,
|
||
/// Required. The zero-based index of the channel in the output audio stream.
|
||
#[serde(rename="outputChannel")]
|
||
|
||
pub output_channel: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for AudioMapping {}
|
||
|
||
|
||
/// Audio stream resource.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AudioStream {
|
||
/// Required. Audio bitrate in bits per second. Must be between 1 and 10,000,000.
|
||
#[serde(rename="bitrateBps")]
|
||
|
||
pub bitrate_bps: Option<i32>,
|
||
/// Number of audio channels. Must be between 1 and 6. The default is 2.
|
||
#[serde(rename="channelCount")]
|
||
|
||
pub channel_count: Option<i32>,
|
||
/// A list of channel names specifying layout of the audio channels. This only affects the metadata embedded in the container headers, if supported by the specified format. The default is `["fl", "fr"]`. Supported channel names: - `fl` - Front left channel - `fr` - Front right channel - `sl` - Side left channel - `sr` - Side right channel - `fc` - Front center channel - `lfe` - Low frequency
|
||
#[serde(rename="channelLayout")]
|
||
|
||
pub channel_layout: Option<Vec<String>>,
|
||
/// The codec for this audio stream. The default is `aac`. Supported audio codecs: - `aac` - `aac-he` - `aac-he-v2` - `mp3` - `ac3` - `eac3`
|
||
|
||
pub codec: Option<String>,
|
||
/// The name for this particular audio stream that will be added to the HLS/DASH manifest. Not supported in MP4 files.
|
||
#[serde(rename="displayName")]
|
||
|
||
pub display_name: Option<String>,
|
||
/// The BCP-47 language code, such as `en-US` or `sr-Latn`. For more information, see https://www.unicode.org/reports/tr35/#Unicode_locale_identifier. Not supported in MP4 files.
|
||
#[serde(rename="languageCode")]
|
||
|
||
pub language_code: Option<String>,
|
||
/// The mapping for the JobConfig.edit_list atoms with audio EditAtom.inputs.
|
||
|
||
pub mapping: Option<Vec<AudioMapping>>,
|
||
/// The audio sample rate in Hertz. The default is 48000 Hertz.
|
||
#[serde(rename="sampleRateHertz")]
|
||
|
||
pub sample_rate_hertz: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for AudioStream {}
|
||
|
||
|
||
/// Bob Weaver Deinterlacing Filter Configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct BwdifConfig {
|
||
/// Deinterlace all frames rather than just the frames identified as interlaced. The default is `false`.
|
||
#[serde(rename="deinterlaceAllFrames")]
|
||
|
||
pub deinterlace_all_frames: Option<bool>,
|
||
/// Specifies the deinterlacing mode to adopt. The default is `send_frame`. Supported values: - `send_frame`: Output one frame for each frame - `send_field`: Output one frame for each field
|
||
|
||
pub mode: Option<String>,
|
||
/// The picture field parity assumed for the input interlaced video. The default is `auto`. Supported values: - `tff`: Assume the top field is first - `bff`: Assume the bottom field is first - `auto`: Enable automatic detection of field parity
|
||
|
||
pub parity: Option<String>,
|
||
}
|
||
|
||
impl client::Part for BwdifConfig {}
|
||
|
||
|
||
/// Clearkey configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Clearkey { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Clearkey {}
|
||
|
||
|
||
/// Color preprocessing configuration. **Note:** This configuration is not supported.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Color {
|
||
/// Control brightness of the video. Enter a value between -1 and 1, where -1 is minimum brightness and 1 is maximum brightness. 0 is no change. The default is 0.
|
||
|
||
pub brightness: Option<f64>,
|
||
/// Control black and white contrast of the video. Enter a value between -1 and 1, where -1 is minimum contrast and 1 is maximum contrast. 0 is no change. The default is 0.
|
||
|
||
pub contrast: Option<f64>,
|
||
/// Control color saturation of the video. Enter a value between -1 and 1, where -1 is fully desaturated and 1 is maximum saturation. 0 is no change. The default is 0.
|
||
|
||
pub saturation: Option<f64>,
|
||
}
|
||
|
||
impl client::Part for Color {}
|
||
|
||
|
||
/// Video cropping configuration for the input video. The cropped input video is scaled to match the output resolution.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Crop {
|
||
/// The number of pixels to crop from the bottom. The default is 0.
|
||
#[serde(rename="bottomPixels")]
|
||
|
||
pub bottom_pixels: Option<i32>,
|
||
/// The number of pixels to crop from the left. The default is 0.
|
||
#[serde(rename="leftPixels")]
|
||
|
||
pub left_pixels: Option<i32>,
|
||
/// The number of pixels to crop from the right. The default is 0.
|
||
#[serde(rename="rightPixels")]
|
||
|
||
pub right_pixels: Option<i32>,
|
||
/// The number of pixels to crop from the top. The default is 0.
|
||
#[serde(rename="topPixels")]
|
||
|
||
pub top_pixels: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for Crop {}
|
||
|
||
|
||
/// `DASH` manifest configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct DashConfig {
|
||
/// The segment reference scheme for a `DASH` manifest. The default is `SEGMENT_LIST`.
|
||
#[serde(rename="segmentReferenceScheme")]
|
||
|
||
pub segment_reference_scheme: Option<String>,
|
||
}
|
||
|
||
impl client::Part for DashConfig {}
|
||
|
||
|
||
/// Deblock preprocessing configuration. **Note:** This configuration is not supported.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Deblock {
|
||
/// Enable deblocker. The default is `false`.
|
||
|
||
pub enabled: Option<bool>,
|
||
/// Set strength of the deblocker. Enter a value between 0 and 1. The higher the value, the stronger the block removal. 0 is no deblocking. The default is 0.
|
||
|
||
pub strength: Option<f64>,
|
||
}
|
||
|
||
impl client::Part for Deblock {}
|
||
|
||
|
||
/// Deinterlace configuration for input video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Deinterlace {
|
||
/// Specifies the Bob Weaver Deinterlacing Filter Configuration.
|
||
|
||
pub bwdif: Option<BwdifConfig>,
|
||
/// Specifies the Yet Another Deinterlacing Filter Configuration.
|
||
|
||
pub yadif: Option<YadifConfig>,
|
||
}
|
||
|
||
impl client::Part for Deinterlace {}
|
||
|
||
|
||
/// Denoise preprocessing configuration. **Note:** This configuration is not supported.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Denoise {
|
||
/// Set strength of the denoise. Enter a value between 0 and 1. The higher the value, the smoother the image. 0 is no denoising. The default is 0.
|
||
|
||
pub strength: Option<f64>,
|
||
/// Set the denoiser mode. The default is `standard`. Supported denoiser modes: - `standard` - `grain`
|
||
|
||
pub tune: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Denoise {}
|
||
|
||
|
||
/// Defines configuration for DRM systems in use.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct DrmSystems {
|
||
/// Clearkey configuration.
|
||
|
||
pub clearkey: Option<Clearkey>,
|
||
/// Fairplay configuration.
|
||
|
||
pub fairplay: Option<Fairplay>,
|
||
/// Playready configuration.
|
||
|
||
pub playready: Option<Playready>,
|
||
/// Widevine configuration.
|
||
|
||
pub widevine: Option<Widevine>,
|
||
}
|
||
|
||
impl client::Part for DrmSystems {}
|
||
|
||
|
||
/// Edit atom.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct EditAtom {
|
||
/// End time in seconds for the atom, relative to the input file timeline. When `end_time_offset` is not specified, the `inputs` are used until the end of the atom.
|
||
#[serde(rename="endTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub end_time_offset: Option<client::chrono::Duration>,
|
||
/// List of Input.key values identifying files that should be used in this atom. The listed `inputs` must have the same timeline.
|
||
|
||
pub inputs: Option<Vec<String>>,
|
||
/// A unique key for this atom. Must be specified when using advanced mapping.
|
||
|
||
pub key: Option<String>,
|
||
/// Start time in seconds for the atom, relative to the input file timeline. The default is `0s`.
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
}
|
||
|
||
impl client::Part for EditAtom {}
|
||
|
||
|
||
/// Encoding of an input file such as an audio, video, or text track. Elementary streams must be packaged before mapping and sharing between different output formats.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ElementaryStream {
|
||
/// Encoding of an audio stream.
|
||
#[serde(rename="audioStream")]
|
||
|
||
pub audio_stream: Option<AudioStream>,
|
||
/// A unique key for this elementary stream.
|
||
|
||
pub key: Option<String>,
|
||
/// Encoding of a text stream. For example, closed captions or subtitles.
|
||
#[serde(rename="textStream")]
|
||
|
||
pub text_stream: Option<TextStream>,
|
||
/// Encoding of a video stream.
|
||
#[serde(rename="videoStream")]
|
||
|
||
pub video_stream: Option<VideoStream>,
|
||
}
|
||
|
||
impl client::Part for ElementaryStream {}
|
||
|
||
|
||
/// A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [locations job templates delete projects](ProjectLocationJobTemplateDeleteCall) (response)
|
||
/// * [locations jobs delete projects](ProjectLocationJobDeleteCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Empty { _never_set: Option<bool> }
|
||
|
||
impl client::ResponseResult for Empty {}
|
||
|
||
|
||
/// Encryption settings.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Encryption {
|
||
/// Configuration for AES-128 encryption.
|
||
|
||
pub aes128: Option<Aes128Encryption>,
|
||
/// Required. DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled.
|
||
#[serde(rename="drmSystems")]
|
||
|
||
pub drm_systems: Option<DrmSystems>,
|
||
/// Required. Identifier for this set of encryption options.
|
||
|
||
pub id: Option<String>,
|
||
/// Configuration for MPEG Common Encryption (MPEG-CENC).
|
||
#[serde(rename="mpegCenc")]
|
||
|
||
pub mpeg_cenc: Option<MpegCommonEncryption>,
|
||
/// Configuration for SAMPLE-AES encryption.
|
||
#[serde(rename="sampleAes")]
|
||
|
||
pub sample_aes: Option<SampleAesEncryption>,
|
||
/// Keys are stored in Google Secret Manager.
|
||
#[serde(rename="secretManagerKeySource")]
|
||
|
||
pub secret_manager_key_source: Option<SecretManagerSource>,
|
||
}
|
||
|
||
impl client::Part for Encryption {}
|
||
|
||
|
||
/// Fairplay configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Fairplay { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Fairplay {}
|
||
|
||
|
||
/// `fmp4` container configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Fmp4Config {
|
||
/// Optional. Specify the codec tag string that will be used in the media bitstream. When not specified, the codec appropriate value is used. Supported H265 codec tags: - `hvc1` (default) - `hev1`
|
||
#[serde(rename="codecTag")]
|
||
|
||
pub codec_tag: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Fmp4Config {}
|
||
|
||
|
||
/// H264 codec settings.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H264CodecSettings {
|
||
/// Specifies whether an open Group of Pictures (GOP) structure should be allowed or not. The default is `false`.
|
||
#[serde(rename="allowOpenGop")]
|
||
|
||
pub allow_open_gop: Option<bool>,
|
||
/// Specify the intensity of the adaptive quantizer (AQ). Must be between 0 and 1, where 0 disables the quantizer and 1 maximizes the quantizer. A higher value equals a lower bitrate but smoother image. The default is 0.
|
||
#[serde(rename="aqStrength")]
|
||
|
||
pub aq_strength: Option<f64>,
|
||
/// The number of consecutive B-frames. Must be greater than or equal to zero. Must be less than H264CodecSettings.gop_frame_count if set. The default is 0.
|
||
#[serde(rename="bFrameCount")]
|
||
|
||
pub b_frame_count: Option<i32>,
|
||
/// Allow B-pyramid for reference frame selection. This may not be supported on all decoders. The default is `false`.
|
||
#[serde(rename="bPyramid")]
|
||
|
||
pub b_pyramid: Option<bool>,
|
||
/// Required. The video bitrate in bits per second. The minimum value is 1,000. The maximum value is 800,000,000.
|
||
#[serde(rename="bitrateBps")]
|
||
|
||
pub bitrate_bps: Option<i32>,
|
||
/// Target CRF level. Must be between 10 and 36, where 10 is the highest quality and 36 is the most efficient compression. The default is 21.
|
||
#[serde(rename="crfLevel")]
|
||
|
||
pub crf_level: Option<i32>,
|
||
/// Use two-pass encoding strategy to achieve better video quality. H264CodecSettings.rate_control_mode must be `vbr`. The default is `false`.
|
||
#[serde(rename="enableTwoPass")]
|
||
|
||
pub enable_two_pass: Option<bool>,
|
||
/// The entropy coder to use. The default is `cabac`. Supported entropy coders: - `cavlc` - `cabac`
|
||
#[serde(rename="entropyCoder")]
|
||
|
||
pub entropy_coder: Option<String>,
|
||
/// Required. The target video frame rate in frames per second (FPS). Must be less than or equal to 120.
|
||
#[serde(rename="frameRate")]
|
||
|
||
pub frame_rate: Option<f64>,
|
||
/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
|
||
#[serde(rename="frameRateConversionStrategy")]
|
||
|
||
pub frame_rate_conversion_strategy: Option<String>,
|
||
/// Select the GOP size based on the specified duration. The default is `3s`. Note that `gopDuration` must be less than or equal to [`segmentDuration`](#SegmentSettings), and [`segmentDuration`](#SegmentSettings) must be divisible by `gopDuration`.
|
||
#[serde(rename="gopDuration")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub gop_duration: Option<client::chrono::Duration>,
|
||
/// Select the GOP size based on the specified frame count. Must be greater than zero.
|
||
#[serde(rename="gopFrameCount")]
|
||
|
||
pub gop_frame_count: Option<i32>,
|
||
/// The height of the video in pixels. Must be an even integer. When not specified, the height is adjusted to match the specified width and input aspect ratio. If both are omitted, the input height is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the height, in pixels, per the horizontal ASR. The API calculates the width per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="heightPixels")]
|
||
|
||
pub height_pixels: Option<i32>,
|
||
/// Optional. HLG color format setting for H264.
|
||
|
||
pub hlg: Option<H264ColorFormatHLG>,
|
||
/// Pixel format to use. The default is `yuv420p`. Supported pixel formats: - `yuv420p` pixel format - `yuv422p` pixel format - `yuv444p` pixel format - `yuv420p10` 10-bit HDR pixel format - `yuv422p10` 10-bit HDR pixel format - `yuv444p10` 10-bit HDR pixel format - `yuv420p12` 12-bit HDR pixel format - `yuv422p12` 12-bit HDR pixel format - `yuv444p12` 12-bit HDR pixel format
|
||
#[serde(rename="pixelFormat")]
|
||
|
||
pub pixel_format: Option<String>,
|
||
/// Enforces the specified codec preset. The default is `veryfast`. The available options are [FFmpeg-compatible](https://trac.ffmpeg.org/wiki/Encode/H.264#Preset). Note that certain values for this field may cause the transcoder to override other fields you set in the `H264CodecSettings` message.
|
||
|
||
pub preset: Option<String>,
|
||
/// Enforces the specified codec profile. The following profiles are supported: * `baseline` * `main` * `high` (default) The available options are [FFmpeg-compatible](https://trac.ffmpeg.org/wiki/Encode/H.264#Tune). Note that certain values for this field may cause the transcoder to override other fields you set in the `H264CodecSettings` message.
|
||
|
||
pub profile: Option<String>,
|
||
/// Specify the mode. The default is `vbr`. Supported rate control modes: - `vbr` - variable bitrate - `crf` - constant rate factor
|
||
#[serde(rename="rateControlMode")]
|
||
|
||
pub rate_control_mode: Option<String>,
|
||
/// Optional. SDR color format setting for H264.
|
||
|
||
pub sdr: Option<H264ColorFormatSDR>,
|
||
/// Enforces the specified codec tune. The available options are [FFmpeg-compatible](https://trac.ffmpeg.org/wiki/Encode/H.264#Tune). Note that certain values for this field may cause the transcoder to override other fields you set in the `H264CodecSettings` message.
|
||
|
||
pub tune: Option<String>,
|
||
/// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits. Must be greater than zero. The default is equal to 90% of H264CodecSettings.vbv_size_bits.
|
||
#[serde(rename="vbvFullnessBits")]
|
||
|
||
pub vbv_fullness_bits: Option<i32>,
|
||
/// Size of the Video Buffering Verifier (VBV) buffer in bits. Must be greater than zero. The default is equal to H264CodecSettings.bitrate_bps.
|
||
#[serde(rename="vbvSizeBits")]
|
||
|
||
pub vbv_size_bits: Option<i32>,
|
||
/// The width of the video in pixels. Must be an even integer. When not specified, the width is adjusted to match the specified height and input aspect ratio. If both are omitted, the input width is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the width, in pixels, per the horizontal ASR. The API calculates the height per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="widthPixels")]
|
||
|
||
pub width_pixels: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for H264CodecSettings {}
|
||
|
||
|
||
/// Convert the input video to a Hybrid Log Gamma (HLG) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H264ColorFormatHLG { _never_set: Option<bool> }
|
||
|
||
impl client::Part for H264ColorFormatHLG {}
|
||
|
||
|
||
/// Convert the input video to a Standard Dynamic Range (SDR) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H264ColorFormatSDR { _never_set: Option<bool> }
|
||
|
||
impl client::Part for H264ColorFormatSDR {}
|
||
|
||
|
||
/// H265 codec settings.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H265CodecSettings {
|
||
/// Specifies whether an open Group of Pictures (GOP) structure should be allowed or not. The default is `false`.
|
||
#[serde(rename="allowOpenGop")]
|
||
|
||
pub allow_open_gop: Option<bool>,
|
||
/// Specify the intensity of the adaptive quantizer (AQ). Must be between 0 and 1, where 0 disables the quantizer and 1 maximizes the quantizer. A higher value equals a lower bitrate but smoother image. The default is 0.
|
||
#[serde(rename="aqStrength")]
|
||
|
||
pub aq_strength: Option<f64>,
|
||
/// The number of consecutive B-frames. Must be greater than or equal to zero. Must be less than H265CodecSettings.gop_frame_count if set. The default is 0.
|
||
#[serde(rename="bFrameCount")]
|
||
|
||
pub b_frame_count: Option<i32>,
|
||
/// Allow B-pyramid for reference frame selection. This may not be supported on all decoders. The default is `false`.
|
||
#[serde(rename="bPyramid")]
|
||
|
||
pub b_pyramid: Option<bool>,
|
||
/// Required. The video bitrate in bits per second. The minimum value is 1,000. The maximum value is 800,000,000.
|
||
#[serde(rename="bitrateBps")]
|
||
|
||
pub bitrate_bps: Option<i32>,
|
||
/// Target CRF level. Must be between 10 and 36, where 10 is the highest quality and 36 is the most efficient compression. The default is 21.
|
||
#[serde(rename="crfLevel")]
|
||
|
||
pub crf_level: Option<i32>,
|
||
/// Use two-pass encoding strategy to achieve better video quality. H265CodecSettings.rate_control_mode must be `vbr`. The default is `false`.
|
||
#[serde(rename="enableTwoPass")]
|
||
|
||
pub enable_two_pass: Option<bool>,
|
||
/// Required. The target video frame rate in frames per second (FPS). Must be less than or equal to 120.
|
||
#[serde(rename="frameRate")]
|
||
|
||
pub frame_rate: Option<f64>,
|
||
/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
|
||
#[serde(rename="frameRateConversionStrategy")]
|
||
|
||
pub frame_rate_conversion_strategy: Option<String>,
|
||
/// Select the GOP size based on the specified duration. The default is `3s`. Note that `gopDuration` must be less than or equal to [`segmentDuration`](#SegmentSettings), and [`segmentDuration`](#SegmentSettings) must be divisible by `gopDuration`.
|
||
#[serde(rename="gopDuration")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub gop_duration: Option<client::chrono::Duration>,
|
||
/// Select the GOP size based on the specified frame count. Must be greater than zero.
|
||
#[serde(rename="gopFrameCount")]
|
||
|
||
pub gop_frame_count: Option<i32>,
|
||
/// Optional. HDR10 color format setting for H265.
|
||
|
||
pub hdr10: Option<H265ColorFormatHDR10>,
|
||
/// The height of the video in pixels. Must be an even integer. When not specified, the height is adjusted to match the specified width and input aspect ratio. If both are omitted, the input height is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the height, in pixels, per the horizontal ASR. The API calculates the width per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="heightPixels")]
|
||
|
||
pub height_pixels: Option<i32>,
|
||
/// Optional. HLG color format setting for H265.
|
||
|
||
pub hlg: Option<H265ColorFormatHLG>,
|
||
/// Pixel format to use. The default is `yuv420p`. Supported pixel formats: - `yuv420p` pixel format - `yuv422p` pixel format - `yuv444p` pixel format - `yuv420p10` 10-bit HDR pixel format - `yuv422p10` 10-bit HDR pixel format - `yuv444p10` 10-bit HDR pixel format - `yuv420p12` 12-bit HDR pixel format - `yuv422p12` 12-bit HDR pixel format - `yuv444p12` 12-bit HDR pixel format
|
||
#[serde(rename="pixelFormat")]
|
||
|
||
pub pixel_format: Option<String>,
|
||
/// Enforces the specified codec preset. The default is `veryfast`. The available options are [FFmpeg-compatible](https://trac.ffmpeg.org/wiki/Encode/H.265). Note that certain values for this field may cause the transcoder to override other fields you set in the `H265CodecSettings` message.
|
||
|
||
pub preset: Option<String>,
|
||
/// Enforces the specified codec profile. The following profiles are supported: * 8-bit profiles * `main` (default) * `main-intra` * `mainstillpicture` * 10-bit profiles * `main10` (default) * `main10-intra` * `main422-10` * `main422-10-intra` * `main444-10` * `main444-10-intra` * 12-bit profiles * `main12` (default) * `main12-intra` * `main422-12` * `main422-12-intra` * `main444-12` * `main444-12-intra` The available options are [FFmpeg-compatible](https://x265.readthedocs.io/). Note that certain values for this field may cause the transcoder to override other fields you set in the `H265CodecSettings` message.
|
||
|
||
pub profile: Option<String>,
|
||
/// Specify the mode. The default is `vbr`. Supported rate control modes: - `vbr` - variable bitrate - `crf` - constant rate factor
|
||
#[serde(rename="rateControlMode")]
|
||
|
||
pub rate_control_mode: Option<String>,
|
||
/// Optional. SDR color format setting for H265.
|
||
|
||
pub sdr: Option<H265ColorFormatSDR>,
|
||
/// Enforces the specified codec tune. The available options are [FFmpeg-compatible](https://trac.ffmpeg.org/wiki/Encode/H.265). Note that certain values for this field may cause the transcoder to override other fields you set in the `H265CodecSettings` message.
|
||
|
||
pub tune: Option<String>,
|
||
/// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits. Must be greater than zero. The default is equal to 90% of H265CodecSettings.vbv_size_bits.
|
||
#[serde(rename="vbvFullnessBits")]
|
||
|
||
pub vbv_fullness_bits: Option<i32>,
|
||
/// Size of the Video Buffering Verifier (VBV) buffer in bits. Must be greater than zero. The default is equal to `VideoStream.bitrate_bps`.
|
||
#[serde(rename="vbvSizeBits")]
|
||
|
||
pub vbv_size_bits: Option<i32>,
|
||
/// The width of the video in pixels. Must be an even integer. When not specified, the width is adjusted to match the specified height and input aspect ratio. If both are omitted, the input width is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the width, in pixels, per the horizontal ASR. The API calculates the height per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="widthPixels")]
|
||
|
||
pub width_pixels: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for H265CodecSettings {}
|
||
|
||
|
||
/// Convert the input video to a High Dynamic Range 10 (HDR10) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H265ColorFormatHDR10 { _never_set: Option<bool> }
|
||
|
||
impl client::Part for H265ColorFormatHDR10 {}
|
||
|
||
|
||
/// Convert the input video to a Hybrid Log Gamma (HLG) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H265ColorFormatHLG { _never_set: Option<bool> }
|
||
|
||
impl client::Part for H265ColorFormatHLG {}
|
||
|
||
|
||
/// Convert the input video to a Standard Dynamic Range (SDR) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct H265ColorFormatSDR { _never_set: Option<bool> }
|
||
|
||
impl client::Part for H265ColorFormatSDR {}
|
||
|
||
|
||
/// Overlaid image.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Image {
|
||
/// Target image opacity. Valid values are from `1.0` (solid, default) to `0.0` (transparent), exclusive. Set this to a value greater than `0.0`.
|
||
|
||
pub alpha: Option<f64>,
|
||
/// Normalized image resolution, based on output video resolution. Valid values: `0.0`–`1.0`. To respect the original image aspect ratio, set either `x` or `y` to `0.0`. To use the original image resolution, set both `x` and `y` to `0.0`.
|
||
|
||
pub resolution: Option<NormalizedCoordinate>,
|
||
/// Required. URI of the image in Cloud Storage. For example, `gs://bucket/inputs/image.png`. Only PNG and JPEG images are supported.
|
||
|
||
pub uri: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Image {}
|
||
|
||
|
||
/// Input asset.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Input {
|
||
/// A unique key for this input. Must be specified when using advanced mapping and edit lists.
|
||
|
||
pub key: Option<String>,
|
||
/// Preprocessing configurations.
|
||
#[serde(rename="preprocessingConfig")]
|
||
|
||
pub preprocessing_config: Option<PreprocessingConfig>,
|
||
/// URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, `gs://bucket/inputs/file.mp4`). If empty, the value is populated from Job.input_uri. See [Supported input and output formats](https://cloud.google.com/transcoder/docs/concepts/supported-input-and-output-formats).
|
||
|
||
pub uri: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Input {}
|
||
|
||
|
||
/// Transcoding job resource.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [locations jobs create projects](ProjectLocationJobCreateCall) (request|response)
|
||
/// * [locations jobs get projects](ProjectLocationJobGetCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Job {
|
||
/// The processing priority of a batch job. This field can only be set for batch mode jobs. The default value is 0. This value cannot be negative. Higher values correspond to higher priorities for the job.
|
||
#[serde(rename="batchModePriority")]
|
||
|
||
pub batch_mode_priority: Option<i32>,
|
||
/// The configuration for this job.
|
||
|
||
pub config: Option<JobConfig>,
|
||
/// Output only. The time the job was created.
|
||
#[serde(rename="createTime")]
|
||
|
||
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
|
||
/// Output only. The time the transcoding finished.
|
||
#[serde(rename="endTime")]
|
||
|
||
pub end_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
|
||
/// Output only. An error object that describes the reason for the failure. This property is always present when ProcessingState is `FAILED`.
|
||
|
||
pub error: Option<Status>,
|
||
/// Input only. Specify the `input_uri` to populate empty `uri` fields in each element of `Job.config.inputs` or `JobTemplate.config.inputs` when using template. URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, `gs://bucket/inputs/file.mp4`). See [Supported input and output formats](https://cloud.google.com/transcoder/docs/concepts/supported-input-and-output-formats).
|
||
#[serde(rename="inputUri")]
|
||
|
||
pub input_uri: Option<String>,
|
||
/// The labels associated with this job. You can use these to organize and group your jobs.
|
||
|
||
pub labels: Option<HashMap<String, String>>,
|
||
/// The processing mode of the job. The default is `PROCESSING_MODE_INTERACTIVE`.
|
||
|
||
pub mode: Option<String>,
|
||
/// The resource name of the job. Format: `projects/{project_number}/locations/{location}/jobs/{job}`
|
||
|
||
pub name: Option<String>,
|
||
/// Optional. The optimization strategy of the job. The default is `AUTODETECT`.
|
||
|
||
pub optimization: Option<String>,
|
||
/// Input only. Specify the `output_uri` to populate an empty `Job.config.output.uri` or `JobTemplate.config.output.uri` when using template. URI for the output file(s). For example, `gs://my-bucket/outputs/`. See [Supported input and output formats](https://cloud.google.com/transcoder/docs/concepts/supported-input-and-output-formats).
|
||
#[serde(rename="outputUri")]
|
||
|
||
pub output_uri: Option<String>,
|
||
/// Output only. The time the transcoding started.
|
||
#[serde(rename="startTime")]
|
||
|
||
pub start_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
|
||
/// Output only. The current state of the job.
|
||
|
||
pub state: Option<String>,
|
||
/// Input only. Specify the `template_id` to use for populating `Job.config`. The default is `preset/web-hd`, which is the only supported preset. User defined JobTemplate: `{job_template_id}`
|
||
#[serde(rename="templateId")]
|
||
|
||
pub template_id: Option<String>,
|
||
/// Job time to live value in days, which will be effective after job completion. Job should be deleted automatically after the given TTL. Enter a value between 1 and 90. The default is 30.
|
||
#[serde(rename="ttlAfterCompletionDays")]
|
||
|
||
pub ttl_after_completion_days: Option<i32>,
|
||
}
|
||
|
||
impl client::RequestValue for Job {}
|
||
impl client::ResponseResult for Job {}
|
||
|
||
|
||
/// Job configuration
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct JobConfig {
|
||
/// List of ad breaks. Specifies where to insert ad break tags in the output manifests.
|
||
#[serde(rename="adBreaks")]
|
||
|
||
pub ad_breaks: Option<Vec<AdBreak>>,
|
||
/// List of edit atoms. Defines the ultimate timeline of the resulting file or manifest.
|
||
#[serde(rename="editList")]
|
||
|
||
pub edit_list: Option<Vec<EditAtom>>,
|
||
/// List of elementary streams.
|
||
#[serde(rename="elementaryStreams")]
|
||
|
||
pub elementary_streams: Option<Vec<ElementaryStream>>,
|
||
/// List of encryption configurations for the content. Each configuration has an ID. Specify this ID in the MuxStream.encryption_id field to indicate the configuration to use for that `MuxStream` output.
|
||
|
||
pub encryptions: Option<Vec<Encryption>>,
|
||
/// List of input assets stored in Cloud Storage.
|
||
|
||
pub inputs: Option<Vec<Input>>,
|
||
/// List of output manifests.
|
||
|
||
pub manifests: Option<Vec<Manifest>>,
|
||
/// List of multiplexing settings for output streams.
|
||
#[serde(rename="muxStreams")]
|
||
|
||
pub mux_streams: Option<Vec<MuxStream>>,
|
||
/// Output configuration.
|
||
|
||
pub output: Option<Output>,
|
||
/// List of overlays on the output video, in descending Z-order.
|
||
|
||
pub overlays: Option<Vec<Overlay>>,
|
||
/// Destination on Pub/Sub.
|
||
#[serde(rename="pubsubDestination")]
|
||
|
||
pub pubsub_destination: Option<PubsubDestination>,
|
||
/// List of output sprite sheets. Spritesheets require at least one VideoStream in the Jobconfig.
|
||
#[serde(rename="spriteSheets")]
|
||
|
||
pub sprite_sheets: Option<Vec<SpriteSheet>>,
|
||
}
|
||
|
||
impl client::Part for JobConfig {}
|
||
|
||
|
||
/// Transcoding job template resource.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [locations job templates create projects](ProjectLocationJobTemplateCreateCall) (request|response)
|
||
/// * [locations job templates get projects](ProjectLocationJobTemplateGetCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct JobTemplate {
|
||
/// The configuration for this template.
|
||
|
||
pub config: Option<JobConfig>,
|
||
/// The labels associated with this job template. You can use these to organize and group your job templates.
|
||
|
||
pub labels: Option<HashMap<String, String>>,
|
||
/// The resource name of the job template. Format: `projects/{project_number}/locations/{location}/jobTemplates/{job_template}`
|
||
|
||
pub name: Option<String>,
|
||
}
|
||
|
||
impl client::RequestValue for JobTemplate {}
|
||
impl client::ResponseResult for JobTemplate {}
|
||
|
||
|
||
/// Response message for `TranscoderService.ListJobTemplates`.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [locations job templates list projects](ProjectLocationJobTemplateListCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ListJobTemplatesResponse {
|
||
/// List of job templates in the specified region.
|
||
#[serde(rename="jobTemplates")]
|
||
|
||
pub job_templates: Option<Vec<JobTemplate>>,
|
||
/// The pagination token.
|
||
#[serde(rename="nextPageToken")]
|
||
|
||
pub next_page_token: Option<String>,
|
||
/// List of regions that could not be reached.
|
||
|
||
pub unreachable: Option<Vec<String>>,
|
||
}
|
||
|
||
impl client::ResponseResult for ListJobTemplatesResponse {}
|
||
|
||
|
||
/// Response message for `TranscoderService.ListJobs`.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [locations jobs list projects](ProjectLocationJobListCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ListJobsResponse {
|
||
/// List of jobs in the specified region.
|
||
|
||
pub jobs: Option<Vec<Job>>,
|
||
/// The pagination token.
|
||
#[serde(rename="nextPageToken")]
|
||
|
||
pub next_page_token: Option<String>,
|
||
/// List of regions that could not be reached.
|
||
|
||
pub unreachable: Option<Vec<String>>,
|
||
}
|
||
|
||
impl client::ResponseResult for ListJobsResponse {}
|
||
|
||
|
||
/// Manifest configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Manifest {
|
||
/// `DASH` manifest configuration.
|
||
|
||
pub dash: Option<DashConfig>,
|
||
/// The name of the generated file. The default is `manifest` with the extension suffix corresponding to the Manifest.type.
|
||
#[serde(rename="fileName")]
|
||
|
||
pub file_name: Option<String>,
|
||
/// Required. List of user supplied MuxStream.key values that should appear in this manifest. When Manifest.type is `HLS`, a media manifest with name MuxStream.key and `.m3u8` extension is generated for each element in this list.
|
||
#[serde(rename="muxStreams")]
|
||
|
||
pub mux_streams: Option<Vec<String>>,
|
||
/// Required. Type of the manifest.
|
||
#[serde(rename="type")]
|
||
|
||
pub type_: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Manifest {}
|
||
|
||
|
||
/// Configuration for MPEG Common Encryption (MPEG-CENC).
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct MpegCommonEncryption {
|
||
/// Required. Specify the encryption scheme. Supported encryption schemes: - `cenc` - `cbcs`
|
||
|
||
pub scheme: Option<String>,
|
||
}
|
||
|
||
impl client::Part for MpegCommonEncryption {}
|
||
|
||
|
||
/// Multiplexing settings for output stream.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct MuxStream {
|
||
/// The container format. The default is `mp4` Supported container formats: - `ts` - `fmp4`- the corresponding file extension is `.m4s` - `mp4` - `vtt` See also: [Supported input and output formats](https://cloud.google.com/transcoder/docs/concepts/supported-input-and-output-formats)
|
||
|
||
pub container: Option<String>,
|
||
/// List of ElementaryStream.key values multiplexed in this stream.
|
||
#[serde(rename="elementaryStreams")]
|
||
|
||
pub elementary_streams: Option<Vec<String>>,
|
||
/// Identifier of the encryption configuration to use. If omitted, output will be unencrypted.
|
||
#[serde(rename="encryptionId")]
|
||
|
||
pub encryption_id: Option<String>,
|
||
/// The name of the generated file. The default is MuxStream.key with the extension suffix corresponding to the MuxStream.container. Individual segments also have an incremental 10-digit zero-padded suffix starting from 0 before the extension, such as `mux_stream0000000123.ts`.
|
||
#[serde(rename="fileName")]
|
||
|
||
pub file_name: Option<String>,
|
||
/// Optional. `fmp4` container configuration.
|
||
|
||
pub fmp4: Option<Fmp4Config>,
|
||
/// A unique key for this multiplexed stream.
|
||
|
||
pub key: Option<String>,
|
||
/// Segment settings for `ts`, `fmp4` and `vtt`.
|
||
#[serde(rename="segmentSettings")]
|
||
|
||
pub segment_settings: Option<SegmentSettings>,
|
||
}
|
||
|
||
impl client::Part for MuxStream {}
|
||
|
||
|
||
/// 2D normalized coordinates. Default: `{0.0, 0.0}`
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct NormalizedCoordinate {
|
||
/// Normalized x coordinate.
|
||
|
||
pub x: Option<f64>,
|
||
/// Normalized y coordinate.
|
||
|
||
pub y: Option<f64>,
|
||
}
|
||
|
||
impl client::Part for NormalizedCoordinate {}
|
||
|
||
|
||
/// Location of output file(s) in a Cloud Storage bucket.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Output {
|
||
/// URI for the output file(s). For example, `gs://my-bucket/outputs/`. If empty, the value is populated from Job.output_uri. See [Supported input and output formats](https://cloud.google.com/transcoder/docs/concepts/supported-input-and-output-formats).
|
||
|
||
pub uri: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Output {}
|
||
|
||
|
||
/// Overlay configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Overlay {
|
||
/// List of animations. The list should be chronological, without any time overlap.
|
||
|
||
pub animations: Option<Vec<Animation>>,
|
||
/// Image overlay.
|
||
|
||
pub image: Option<Image>,
|
||
}
|
||
|
||
impl client::Part for Overlay {}
|
||
|
||
|
||
/// Pad filter configuration for the input video. The padded input video is scaled after padding with black to match the output resolution.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Pad {
|
||
/// The number of pixels to add to the bottom. The default is 0.
|
||
#[serde(rename="bottomPixels")]
|
||
|
||
pub bottom_pixels: Option<i32>,
|
||
/// The number of pixels to add to the left. The default is 0.
|
||
#[serde(rename="leftPixels")]
|
||
|
||
pub left_pixels: Option<i32>,
|
||
/// The number of pixels to add to the right. The default is 0.
|
||
#[serde(rename="rightPixels")]
|
||
|
||
pub right_pixels: Option<i32>,
|
||
/// The number of pixels to add to the top. The default is 0.
|
||
#[serde(rename="topPixels")]
|
||
|
||
pub top_pixels: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for Pad {}
|
||
|
||
|
||
/// Playready configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Playready { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Playready {}
|
||
|
||
|
||
/// Preprocessing configurations.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct PreprocessingConfig {
|
||
/// Audio preprocessing configuration.
|
||
|
||
pub audio: Option<Audio>,
|
||
/// Color preprocessing configuration.
|
||
|
||
pub color: Option<Color>,
|
||
/// Specify the video cropping configuration.
|
||
|
||
pub crop: Option<Crop>,
|
||
/// Deblock preprocessing configuration.
|
||
|
||
pub deblock: Option<Deblock>,
|
||
/// Specify the video deinterlace configuration.
|
||
|
||
pub deinterlace: Option<Deinterlace>,
|
||
/// Denoise preprocessing configuration.
|
||
|
||
pub denoise: Option<Denoise>,
|
||
/// Specify the video pad filter configuration.
|
||
|
||
pub pad: Option<Pad>,
|
||
}
|
||
|
||
impl client::Part for PreprocessingConfig {}
|
||
|
||
|
||
/// A Pub/Sub destination.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct PubsubDestination {
|
||
/// The name of the Pub/Sub topic to publish job completion notification to. For example: `projects/{project}/topics/{topic}`.
|
||
|
||
pub topic: Option<String>,
|
||
}
|
||
|
||
impl client::Part for PubsubDestination {}
|
||
|
||
|
||
/// Configuration for SAMPLE-AES encryption.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct SampleAesEncryption { _never_set: Option<bool> }
|
||
|
||
impl client::Part for SampleAesEncryption {}
|
||
|
||
|
||
/// Configuration for secrets stored in Google Secret Manager.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct SecretManagerSource {
|
||
/// Required. The name of the Secret Version containing the encryption key in the following format: `projects/{project}/secrets/{secret_id}/versions/{version_number}` Note that only numbered versions are supported. Aliases like "latest" are not supported.
|
||
#[serde(rename="secretVersion")]
|
||
|
||
pub secret_version: Option<String>,
|
||
}
|
||
|
||
impl client::Part for SecretManagerSource {}
|
||
|
||
|
||
/// Segment settings for `ts`, `fmp4` and `vtt`.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct SegmentSettings {
|
||
/// Required. Create an individual segment file. The default is `false`.
|
||
#[serde(rename="individualSegments")]
|
||
|
||
pub individual_segments: Option<bool>,
|
||
/// Duration of the segments in seconds. The default is `6.0s`. Note that `segmentDuration` must be greater than or equal to [`gopDuration`](#videostream), and `segmentDuration` must be divisible by [`gopDuration`](#videostream).
|
||
#[serde(rename="segmentDuration")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub segment_duration: Option<client::chrono::Duration>,
|
||
}
|
||
|
||
impl client::Part for SegmentSettings {}
|
||
|
||
|
||
/// Sprite sheet configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct SpriteSheet {
|
||
/// The maximum number of sprites per row in a sprite sheet. The default is 0, which indicates no maximum limit.
|
||
#[serde(rename="columnCount")]
|
||
|
||
pub column_count: Option<i32>,
|
||
/// End time in seconds, relative to the output file timeline. When `end_time_offset` is not specified, the sprites are generated until the end of the output file.
|
||
#[serde(rename="endTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub end_time_offset: Option<client::chrono::Duration>,
|
||
/// Required. File name prefix for the generated sprite sheets. Each sprite sheet has an incremental 10-digit zero-padded suffix starting from 0 before the extension, such as `sprite_sheet0000000123.jpeg`.
|
||
#[serde(rename="filePrefix")]
|
||
|
||
pub file_prefix: Option<String>,
|
||
/// Format type. The default is `jpeg`. Supported formats: - `jpeg`
|
||
|
||
pub format: Option<String>,
|
||
/// Starting from `0s`, create sprites at regular intervals. Specify the interval value in seconds.
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub interval: Option<client::chrono::Duration>,
|
||
/// The quality of the generated sprite sheet. Enter a value between 1 and 100, where 1 is the lowest quality and 100 is the highest quality. The default is 100. A high quality value corresponds to a low image data compression ratio.
|
||
|
||
pub quality: Option<i32>,
|
||
/// The maximum number of rows per sprite sheet. When the sprite sheet is full, a new sprite sheet is created. The default is 0, which indicates no maximum limit.
|
||
#[serde(rename="rowCount")]
|
||
|
||
pub row_count: Option<i32>,
|
||
/// Required. The height of sprite in pixels. Must be an even integer. To preserve the source aspect ratio, set the SpriteSheet.sprite_height_pixels field or the SpriteSheet.sprite_width_pixels field, but not both (the API will automatically calculate the missing field). For portrait videos that contain horizontal ASR and rotation metadata, provide the height, in pixels, per the horizontal ASR. The API calculates the width per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="spriteHeightPixels")]
|
||
|
||
pub sprite_height_pixels: Option<i32>,
|
||
/// Required. The width of sprite in pixels. Must be an even integer. To preserve the source aspect ratio, set the SpriteSheet.sprite_width_pixels field or the SpriteSheet.sprite_height_pixels field, but not both (the API will automatically calculate the missing field). For portrait videos that contain horizontal ASR and rotation metadata, provide the width, in pixels, per the horizontal ASR. The API calculates the height per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="spriteWidthPixels")]
|
||
|
||
pub sprite_width_pixels: Option<i32>,
|
||
/// Start time in seconds, relative to the output file timeline. Determines the first sprite to pick. The default is `0s`.
|
||
#[serde(rename="startTimeOffset")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub start_time_offset: Option<client::chrono::Duration>,
|
||
/// Total number of sprites. Create the specified number of sprites distributed evenly across the timeline of the output media. The default is 100.
|
||
#[serde(rename="totalCount")]
|
||
|
||
pub total_count: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for SpriteSheet {}
|
||
|
||
|
||
/// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Status {
|
||
/// The status code, which should be an enum value of google.rpc.Code.
|
||
|
||
pub code: Option<i32>,
|
||
/// A list of messages that carry the error details. There is a common set of message types for APIs to use.
|
||
|
||
pub details: Option<Vec<HashMap<String, json::Value>>>,
|
||
/// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
|
||
|
||
pub message: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Status {}
|
||
|
||
|
||
/// The mapping for the JobConfig.edit_list atoms with text EditAtom.inputs.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct TextMapping {
|
||
/// Required. The EditAtom.key that references atom with text inputs in the JobConfig.edit_list.
|
||
#[serde(rename="atomKey")]
|
||
|
||
pub atom_key: Option<String>,
|
||
/// Required. The Input.key that identifies the input file.
|
||
#[serde(rename="inputKey")]
|
||
|
||
pub input_key: Option<String>,
|
||
/// Required. The zero-based index of the track in the input file.
|
||
#[serde(rename="inputTrack")]
|
||
|
||
pub input_track: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for TextMapping {}
|
||
|
||
|
||
/// Encoding of a text stream. For example, closed captions or subtitles.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct TextStream {
|
||
/// The codec for this text stream. The default is `webvtt`. Supported text codecs: - `srt` - `ttml` - `cea608` - `cea708` - `webvtt`
|
||
|
||
pub codec: Option<String>,
|
||
/// The name for this particular text stream that will be added to the HLS/DASH manifest. Not supported in MP4 files.
|
||
#[serde(rename="displayName")]
|
||
|
||
pub display_name: Option<String>,
|
||
/// The BCP-47 language code, such as `en-US` or `sr-Latn`. For more information, see https://www.unicode.org/reports/tr35/#Unicode_locale_identifier. Not supported in MP4 files.
|
||
#[serde(rename="languageCode")]
|
||
|
||
pub language_code: Option<String>,
|
||
/// The mapping for the JobConfig.edit_list atoms with text EditAtom.inputs.
|
||
|
||
pub mapping: Option<Vec<TextMapping>>,
|
||
}
|
||
|
||
impl client::Part for TextStream {}
|
||
|
||
|
||
/// Video stream resource.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct VideoStream {
|
||
/// H264 codec settings.
|
||
|
||
pub h264: Option<H264CodecSettings>,
|
||
/// H265 codec settings.
|
||
|
||
pub h265: Option<H265CodecSettings>,
|
||
/// VP9 codec settings.
|
||
|
||
pub vp9: Option<Vp9CodecSettings>,
|
||
}
|
||
|
||
impl client::Part for VideoStream {}
|
||
|
||
|
||
/// VP9 codec settings.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Vp9CodecSettings {
|
||
/// Required. The video bitrate in bits per second. The minimum value is 1,000. The maximum value is 480,000,000.
|
||
#[serde(rename="bitrateBps")]
|
||
|
||
pub bitrate_bps: Option<i32>,
|
||
/// Target CRF level. Must be between 10 and 36, where 10 is the highest quality and 36 is the most efficient compression. The default is 21. **Note:** This field is not supported.
|
||
#[serde(rename="crfLevel")]
|
||
|
||
pub crf_level: Option<i32>,
|
||
/// Required. The target video frame rate in frames per second (FPS). Must be less than or equal to 120.
|
||
#[serde(rename="frameRate")]
|
||
|
||
pub frame_rate: Option<f64>,
|
||
/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
|
||
#[serde(rename="frameRateConversionStrategy")]
|
||
|
||
pub frame_rate_conversion_strategy: Option<String>,
|
||
/// Select the GOP size based on the specified duration. The default is `3s`. Note that `gopDuration` must be less than or equal to [`segmentDuration`](#SegmentSettings), and [`segmentDuration`](#SegmentSettings) must be divisible by `gopDuration`.
|
||
#[serde(rename="gopDuration")]
|
||
|
||
#[serde_as(as = "Option<::client::serde::duration::Wrapper>")]
|
||
pub gop_duration: Option<client::chrono::Duration>,
|
||
/// Select the GOP size based on the specified frame count. Must be greater than zero.
|
||
#[serde(rename="gopFrameCount")]
|
||
|
||
pub gop_frame_count: Option<i32>,
|
||
/// The height of the video in pixels. Must be an even integer. When not specified, the height is adjusted to match the specified width and input aspect ratio. If both are omitted, the input height is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the height, in pixels, per the horizontal ASR. The API calculates the width per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="heightPixels")]
|
||
|
||
pub height_pixels: Option<i32>,
|
||
/// Optional. HLG color format setting for VP9.
|
||
|
||
pub hlg: Option<Vp9ColorFormatHLG>,
|
||
/// Pixel format to use. The default is `yuv420p`. Supported pixel formats: - `yuv420p` pixel format - `yuv422p` pixel format - `yuv444p` pixel format - `yuv420p10` 10-bit HDR pixel format - `yuv422p10` 10-bit HDR pixel format - `yuv444p10` 10-bit HDR pixel format - `yuv420p12` 12-bit HDR pixel format - `yuv422p12` 12-bit HDR pixel format - `yuv444p12` 12-bit HDR pixel format
|
||
#[serde(rename="pixelFormat")]
|
||
|
||
pub pixel_format: Option<String>,
|
||
/// Enforces the specified codec profile. The following profiles are supported: * `profile0` (default) * `profile1` * `profile2` * `profile3` The available options are [WebM-compatible](https://www.webmproject.org/vp9/profiles/). Note that certain values for this field may cause the transcoder to override other fields you set in the `Vp9CodecSettings` message.
|
||
|
||
pub profile: Option<String>,
|
||
/// Specify the mode. The default is `vbr`. Supported rate control modes: - `vbr` - variable bitrate
|
||
#[serde(rename="rateControlMode")]
|
||
|
||
pub rate_control_mode: Option<String>,
|
||
/// Optional. SDR color format setting for VP9.
|
||
|
||
pub sdr: Option<Vp9ColorFormatSDR>,
|
||
/// The width of the video in pixels. Must be an even integer. When not specified, the width is adjusted to match the specified height and input aspect ratio. If both are omitted, the input width is used. For portrait videos that contain horizontal ASR and rotation metadata, provide the width, in pixels, per the horizontal ASR. The API calculates the height per the horizontal ASR. The API detects any rotation metadata and swaps the requested height and width for the output.
|
||
#[serde(rename="widthPixels")]
|
||
|
||
pub width_pixels: Option<i32>,
|
||
}
|
||
|
||
impl client::Part for Vp9CodecSettings {}
|
||
|
||
|
||
/// Convert the input video to a Hybrid Log Gamma (HLG) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Vp9ColorFormatHLG { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Vp9ColorFormatHLG {}
|
||
|
||
|
||
/// Convert the input video to a Standard Dynamic Range (SDR) video.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Vp9ColorFormatSDR { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Vp9ColorFormatSDR {}
|
||
|
||
|
||
/// Widevine configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Widevine { _never_set: Option<bool> }
|
||
|
||
impl client::Part for Widevine {}
|
||
|
||
|
||
/// Yet Another Deinterlacing Filter Configuration.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct YadifConfig {
|
||
/// Deinterlace all frames rather than just the frames identified as interlaced. The default is `false`.
|
||
#[serde(rename="deinterlaceAllFrames")]
|
||
|
||
pub deinterlace_all_frames: Option<bool>,
|
||
/// Disable spacial interlacing. The default is `false`.
|
||
#[serde(rename="disableSpatialInterlacing")]
|
||
|
||
pub disable_spatial_interlacing: Option<bool>,
|
||
/// Specifies the deinterlacing mode to adopt. The default is `send_frame`. Supported values: - `send_frame`: Output one frame for each frame - `send_field`: Output one frame for each field
|
||
|
||
pub mode: Option<String>,
|
||
/// The picture field parity assumed for the input interlaced video. The default is `auto`. Supported values: - `tff`: Assume the top field is first - `bff`: Assume the bottom field is first - `auto`: Enable automatic detection of field parity
|
||
|
||
pub parity: Option<String>,
|
||
}
|
||
|
||
impl client::Part for YadifConfig {}
|
||
|
||
|
||
|
||
// ###################
|
||
// MethodBuilders ###
|
||
// #################
|
||
|
||
/// A builder providing access to all methods supported on *project* resources.
|
||
/// It is not used directly, but through the [`Transcoder`] hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_transcoder1 as transcoder1;
|
||
///
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `locations_job_templates_create(...)`, `locations_job_templates_delete(...)`, `locations_job_templates_get(...)`, `locations_job_templates_list(...)`, `locations_jobs_create(...)`, `locations_jobs_delete(...)`, `locations_jobs_get(...)` and `locations_jobs_list(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.projects();
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectMethods<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
}
|
||
|
||
impl<'a, S> client::MethodsBuilder for ProjectMethods<'a, S> {}
|
||
|
||
impl<'a, S> ProjectMethods<'a, S> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Creates a job template in the specified region.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `parent` - Required. The parent location to create this job template. Format: `projects/{project}/locations/{location}`
|
||
pub fn locations_job_templates_create(&self, request: JobTemplate, parent: &str) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
ProjectLocationJobTemplateCreateCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_parent: parent.to_string(),
|
||
_job_template_id: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Deletes a job template.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `name` - Required. The name of the job template to delete. `projects/{project}/locations/{location}/jobTemplates/{job_template}`
|
||
pub fn locations_job_templates_delete(&self, name: &str) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
|
||
ProjectLocationJobTemplateDeleteCall {
|
||
hub: self.hub,
|
||
_name: name.to_string(),
|
||
_allow_missing: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Returns the job template data.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `name` - Required. The name of the job template to retrieve. Format: `projects/{project}/locations/{location}/jobTemplates/{job_template}`
|
||
pub fn locations_job_templates_get(&self, name: &str) -> ProjectLocationJobTemplateGetCall<'a, S> {
|
||
ProjectLocationJobTemplateGetCall {
|
||
hub: self.hub,
|
||
_name: name.to_string(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Lists job templates in the specified region.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `parent` - Required. The parent location from which to retrieve the collection of job templates. Format: `projects/{project}/locations/{location}`
|
||
pub fn locations_job_templates_list(&self, parent: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
ProjectLocationJobTemplateListCall {
|
||
hub: self.hub,
|
||
_parent: parent.to_string(),
|
||
_page_token: Default::default(),
|
||
_page_size: Default::default(),
|
||
_order_by: Default::default(),
|
||
_filter: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Creates a job in the specified region.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
/// * `parent` - Required. The parent location to create and process this job. Format: `projects/{project}/locations/{location}`
|
||
pub fn locations_jobs_create(&self, request: Job, parent: &str) -> ProjectLocationJobCreateCall<'a, S> {
|
||
ProjectLocationJobCreateCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_parent: parent.to_string(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Deletes a job.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `name` - Required. The name of the job to delete. Format: `projects/{project}/locations/{location}/jobs/{job}`
|
||
pub fn locations_jobs_delete(&self, name: &str) -> ProjectLocationJobDeleteCall<'a, S> {
|
||
ProjectLocationJobDeleteCall {
|
||
hub: self.hub,
|
||
_name: name.to_string(),
|
||
_allow_missing: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Returns the job data.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `name` - Required. The name of the job to retrieve. Format: `projects/{project}/locations/{location}/jobs/{job}`
|
||
pub fn locations_jobs_get(&self, name: &str) -> ProjectLocationJobGetCall<'a, S> {
|
||
ProjectLocationJobGetCall {
|
||
hub: self.hub,
|
||
_name: name.to_string(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Lists jobs in the specified region.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `parent` - Required. Format: `projects/{project}/locations/{location}`
|
||
pub fn locations_jobs_list(&self, parent: &str) -> ProjectLocationJobListCall<'a, S> {
|
||
ProjectLocationJobListCall {
|
||
hub: self.hub,
|
||
_parent: parent.to_string(),
|
||
_page_token: Default::default(),
|
||
_page_size: Default::default(),
|
||
_order_by: Default::default(),
|
||
_filter: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
_scopes: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// ###################
|
||
// CallBuilders ###
|
||
// #################
|
||
|
||
/// Creates a job template in the specified region.
|
||
///
|
||
/// A builder for the *locations.jobTemplates.create* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// use transcoder1::api::JobTemplate;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = JobTemplate::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_job_templates_create(req, "parent")
|
||
/// .job_template_id("voluptua.")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobTemplateCreateCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_request: JobTemplate,
|
||
_parent: String,
|
||
_job_template_id: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobTemplateCreateCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobTemplateCreateCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, JobTemplate)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobTemplates.create",
|
||
http_method: hyper::Method::POST });
|
||
|
||
for &field in ["alt", "parent", "jobTemplateId"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(5 + self._additional_params.len());
|
||
params.push("parent", self._parent);
|
||
if let Some(value) = self._job_template_id.as_ref() {
|
||
params.push("jobTemplateId", value);
|
||
}
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+parent}/jobTemplates";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["parent"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
let mut json_mime_type = mime::APPLICATION_JSON;
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request).expect("serde to work");
|
||
client::remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::POST)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, json_mime_type.to_string())
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: JobTemplate) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// Required. The parent location to create this job template. Format: `projects/{project}/locations/{location}`
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// Required. The ID to use for the job template, which will become the final component of the job template's resource name. This value should be 4-63 characters, and valid characters must match the regular expression `a-zA-Z*`.
|
||
///
|
||
/// Sets the *job template id* query property to the given value.
|
||
pub fn job_template_id(mut self, new_value: &str) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
self._job_template_id = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobTemplateCreateCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobTemplateCreateCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobTemplateCreateCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobTemplateCreateCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Deletes a job template.
|
||
///
|
||
/// A builder for the *locations.jobTemplates.delete* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_job_templates_delete("name")
|
||
/// .allow_missing(false)
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobTemplateDeleteCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_name: String,
|
||
_allow_missing: Option<bool>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobTemplateDeleteCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobTemplateDeleteCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, Empty)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobTemplates.delete",
|
||
http_method: hyper::Method::DELETE });
|
||
|
||
for &field in ["alt", "name", "allowMissing"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(4 + self._additional_params.len());
|
||
params.push("name", self._name);
|
||
if let Some(value) = self._allow_missing.as_ref() {
|
||
params.push("allowMissing", value.to_string());
|
||
}
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+name}";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["name"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::DELETE)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The name of the job template to delete. `projects/{project}/locations/{location}/jobTemplates/{job_template}`
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// If set to true, and the job template is not found, the request will succeed but no action will be taken on the server.
|
||
///
|
||
/// Sets the *allow missing* query property to the given value.
|
||
pub fn allow_missing(mut self, new_value: bool) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
|
||
self._allow_missing = Some(new_value);
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobTemplateDeleteCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobTemplateDeleteCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobTemplateDeleteCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Returns the job template data.
|
||
///
|
||
/// A builder for the *locations.jobTemplates.get* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_job_templates_get("name")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobTemplateGetCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_name: String,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobTemplateGetCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobTemplateGetCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, JobTemplate)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobTemplates.get",
|
||
http_method: hyper::Method::GET });
|
||
|
||
for &field in ["alt", "name"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(3 + self._additional_params.len());
|
||
params.push("name", self._name);
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+name}";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["name"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::GET)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The name of the job template to retrieve. Format: `projects/{project}/locations/{location}/jobTemplates/{job_template}`
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> ProjectLocationJobTemplateGetCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobTemplateGetCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobTemplateGetCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobTemplateGetCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobTemplateGetCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobTemplateGetCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Lists job templates in the specified region.
|
||
///
|
||
/// A builder for the *locations.jobTemplates.list* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_job_templates_list("parent")
|
||
/// .page_token("amet.")
|
||
/// .page_size(-20)
|
||
/// .order_by("ipsum")
|
||
/// .filter("gubergren")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobTemplateListCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_parent: String,
|
||
_page_token: Option<String>,
|
||
_page_size: Option<i32>,
|
||
_order_by: Option<String>,
|
||
_filter: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobTemplateListCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobTemplateListCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, ListJobTemplatesResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobTemplates.list",
|
||
http_method: hyper::Method::GET });
|
||
|
||
for &field in ["alt", "parent", "pageToken", "pageSize", "orderBy", "filter"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(7 + self._additional_params.len());
|
||
params.push("parent", self._parent);
|
||
if let Some(value) = self._page_token.as_ref() {
|
||
params.push("pageToken", value);
|
||
}
|
||
if let Some(value) = self._page_size.as_ref() {
|
||
params.push("pageSize", value.to_string());
|
||
}
|
||
if let Some(value) = self._order_by.as_ref() {
|
||
params.push("orderBy", value);
|
||
}
|
||
if let Some(value) = self._filter.as_ref() {
|
||
params.push("filter", value);
|
||
}
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+parent}/jobTemplates";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["parent"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::GET)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The parent location from which to retrieve the collection of job templates. Format: `projects/{project}/locations/{location}`
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// The `next_page_token` value returned from a previous List request, if any.
|
||
///
|
||
/// Sets the *page token* query property to the given value.
|
||
pub fn page_token(mut self, new_value: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._page_token = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The maximum number of items to return.
|
||
///
|
||
/// Sets the *page size* query property to the given value.
|
||
pub fn page_size(mut self, new_value: i32) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._page_size = Some(new_value);
|
||
self
|
||
}
|
||
/// One or more fields to compare and use to sort the output. See https://google.aip.dev/132#ordering.
|
||
///
|
||
/// Sets the *order by* query property to the given value.
|
||
pub fn order_by(mut self, new_value: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._order_by = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The filter expression, following the syntax outlined in https://google.aip.dev/160.
|
||
///
|
||
/// Sets the *filter* query property to the given value.
|
||
pub fn filter(mut self, new_value: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._filter = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobTemplateListCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobTemplateListCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobTemplateListCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobTemplateListCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Creates a job in the specified region.
|
||
///
|
||
/// A builder for the *locations.jobs.create* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// use transcoder1::api::Job;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = Job::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_jobs_create(req, "parent")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobCreateCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_request: Job,
|
||
_parent: String,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobCreateCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobCreateCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, Job)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobs.create",
|
||
http_method: hyper::Method::POST });
|
||
|
||
for &field in ["alt", "parent"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(4 + self._additional_params.len());
|
||
params.push("parent", self._parent);
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+parent}/jobs";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["parent"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
let mut json_mime_type = mime::APPLICATION_JSON;
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request).expect("serde to work");
|
||
client::remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::POST)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, json_mime_type.to_string())
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: Job) -> ProjectLocationJobCreateCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// Required. The parent location to create and process this job. Format: `projects/{project}/locations/{location}`
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> ProjectLocationJobCreateCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobCreateCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobCreateCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobCreateCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobCreateCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobCreateCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Deletes a job.
|
||
///
|
||
/// A builder for the *locations.jobs.delete* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_jobs_delete("name")
|
||
/// .allow_missing(false)
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobDeleteCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_name: String,
|
||
_allow_missing: Option<bool>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobDeleteCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobDeleteCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, Empty)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobs.delete",
|
||
http_method: hyper::Method::DELETE });
|
||
|
||
for &field in ["alt", "name", "allowMissing"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(4 + self._additional_params.len());
|
||
params.push("name", self._name);
|
||
if let Some(value) = self._allow_missing.as_ref() {
|
||
params.push("allowMissing", value.to_string());
|
||
}
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+name}";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["name"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::DELETE)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The name of the job to delete. Format: `projects/{project}/locations/{location}/jobs/{job}`
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> ProjectLocationJobDeleteCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// If set to true, and the job is not found, the request will succeed but no action will be taken on the server.
|
||
///
|
||
/// Sets the *allow missing* query property to the given value.
|
||
pub fn allow_missing(mut self, new_value: bool) -> ProjectLocationJobDeleteCall<'a, S> {
|
||
self._allow_missing = Some(new_value);
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobDeleteCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobDeleteCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobDeleteCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobDeleteCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobDeleteCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Returns the job data.
|
||
///
|
||
/// A builder for the *locations.jobs.get* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_jobs_get("name")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobGetCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_name: String,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobGetCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobGetCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, Job)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobs.get",
|
||
http_method: hyper::Method::GET });
|
||
|
||
for &field in ["alt", "name"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(3 + self._additional_params.len());
|
||
params.push("name", self._name);
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+name}";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+name}", "name")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["name"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::GET)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. The name of the job to retrieve. Format: `projects/{project}/locations/{location}/jobs/{job}`
|
||
///
|
||
/// Sets the *name* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn name(mut self, new_value: &str) -> ProjectLocationJobGetCall<'a, S> {
|
||
self._name = new_value.to_string();
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobGetCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobGetCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobGetCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobGetCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobGetCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|
||
/// Lists jobs in the specified region.
|
||
///
|
||
/// A builder for the *locations.jobs.list* method supported by a *project* resource.
|
||
/// It is not used directly, but through a [`ProjectMethods`] instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_transcoder1 as transcoder1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.projects().locations_jobs_list("parent")
|
||
/// .page_token("ipsum")
|
||
/// .page_size(-88)
|
||
/// .order_by("amet")
|
||
/// .filter("duo")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct ProjectLocationJobListCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Transcoder<S>,
|
||
_parent: String,
|
||
_page_token: Option<String>,
|
||
_page_size: Option<i32>,
|
||
_order_by: Option<String>,
|
||
_filter: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
_scopes: BTreeSet<String>
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for ProjectLocationJobListCall<'a, S> {}
|
||
|
||
impl<'a, S> ProjectLocationJobListCall<'a, S>
|
||
where
|
||
S: tower_service::Service<http::Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, ListJobsResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::{ToParts, url::Params};
|
||
use std::borrow::Cow;
|
||
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = self._delegate.unwrap_or(&mut dd);
|
||
dlg.begin(client::MethodInfo { id: "transcoder.projects.locations.jobs.list",
|
||
http_method: hyper::Method::GET });
|
||
|
||
for &field in ["alt", "parent", "pageToken", "pageSize", "orderBy", "filter"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
|
||
let mut params = Params::with_capacity(7 + self._additional_params.len());
|
||
params.push("parent", self._parent);
|
||
if let Some(value) = self._page_token.as_ref() {
|
||
params.push("pageToken", value);
|
||
}
|
||
if let Some(value) = self._page_size.as_ref() {
|
||
params.push("pageSize", value.to_string());
|
||
}
|
||
if let Some(value) = self._order_by.as_ref() {
|
||
params.push("orderBy", value);
|
||
}
|
||
if let Some(value) = self._filter.as_ref() {
|
||
params.push("filter", value);
|
||
}
|
||
|
||
params.extend(self._additional_params.iter());
|
||
|
||
params.push("alt", "json");
|
||
let mut url = self.hub._base_url.clone() + "v1/{+parent}/jobs";
|
||
if self._scopes.is_empty() {
|
||
self._scopes.insert(Scope::CloudPlatform.as_ref().to_string());
|
||
}
|
||
|
||
for &(find_this, param_name) in [("{+parent}", "parent")].iter() {
|
||
url = params.uri_replacement(url, param_name, find_this, true);
|
||
}
|
||
{
|
||
let to_remove = ["parent"];
|
||
params.remove_params(&to_remove);
|
||
}
|
||
|
||
let url = params.parse_with_url(&url);
|
||
|
||
|
||
|
||
loop {
|
||
let token = match self.hub.auth.get_token(&self._scopes.iter().map(String::as_str).collect::<Vec<_>>()[..]).await {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
match dlg.token(e) {
|
||
Ok(token) => token,
|
||
Err(e) => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingToken(e));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder()
|
||
.method(hyper::Method::GET)
|
||
.uri(url.as_str())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
if let Some(token) = token.as_ref() {
|
||
req_builder = req_builder.header(AUTHORIZATION, format!("Bearer {}", token));
|
||
}
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d).await;
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Required. Format: `projects/{project}/locations/{location}`
|
||
///
|
||
/// Sets the *parent* path property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn parent(mut self, new_value: &str) -> ProjectLocationJobListCall<'a, S> {
|
||
self._parent = new_value.to_string();
|
||
self
|
||
}
|
||
/// The `next_page_token` value returned from a previous List request, if any.
|
||
///
|
||
/// Sets the *page token* query property to the given value.
|
||
pub fn page_token(mut self, new_value: &str) -> ProjectLocationJobListCall<'a, S> {
|
||
self._page_token = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The maximum number of items to return.
|
||
///
|
||
/// Sets the *page size* query property to the given value.
|
||
pub fn page_size(mut self, new_value: i32) -> ProjectLocationJobListCall<'a, S> {
|
||
self._page_size = Some(new_value);
|
||
self
|
||
}
|
||
/// One or more fields to compare and use to sort the output. See https://google.aip.dev/132#ordering.
|
||
///
|
||
/// Sets the *order by* query property to the given value.
|
||
pub fn order_by(mut self, new_value: &str) -> ProjectLocationJobListCall<'a, S> {
|
||
self._order_by = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The filter expression, following the syntax outlined in https://google.aip.dev/160.
|
||
///
|
||
/// Sets the *filter* query property to the given value.
|
||
pub fn filter(mut self, new_value: &str) -> ProjectLocationJobListCall<'a, S> {
|
||
self._filter = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// ````text
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
/// ````
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> ProjectLocationJobListCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> ProjectLocationJobListCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
/// Identifies the authorization scope for the method you are building.
|
||
///
|
||
/// Use this method to actively specify which scope should be used, instead of the default [`Scope`] variant
|
||
/// [`Scope::CloudPlatform`].
|
||
///
|
||
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
|
||
/// tokens for more than one scope.
|
||
///
|
||
/// Usually there is more than one suitable scope to authorize an operation, some of which may
|
||
/// encompass more rights than others. For example, for listing resources, a *read-only* scope will be
|
||
/// sufficient, a read-write scope will do as well.
|
||
pub fn add_scope<St>(mut self, scope: St) -> ProjectLocationJobListCall<'a, S>
|
||
where St: AsRef<str> {
|
||
self._scopes.insert(String::from(scope.as_ref()));
|
||
self
|
||
}
|
||
/// Identifies the authorization scope(s) for the method you are building.
|
||
///
|
||
/// See [`Self::add_scope()`] for details.
|
||
pub fn add_scopes<I, St>(mut self, scopes: I) -> ProjectLocationJobListCall<'a, S>
|
||
where I: IntoIterator<Item = St>,
|
||
St: AsRef<str> {
|
||
self._scopes
|
||
.extend(scopes.into_iter().map(|s| String::from(s.as_ref())));
|
||
self
|
||
}
|
||
|
||
/// Removes all scopes, and no default scope will be used either.
|
||
/// In this case, you have to specify your API-key using the `key` parameter (see [`Self::param()`]
|
||
/// for details).
|
||
pub fn clear_scopes(mut self) -> ProjectLocationJobListCall<'a, S> {
|
||
self._scopes.clear();
|
||
self
|
||
}
|
||
}
|
||
|
||
|