/// Http target. The job will be pushed to the job handler by means of
/// an HTTP request via an \[http_method][google.cloud.scheduler.v1.HttpTarget.http_method\] such as HTTP
/// POST, HTTP GET, etc. The job is acknowledged by means of an HTTP
/// response code in the range [200 - 299]. A failure to receive a response
/// constitutes a failed execution. For a redirected request, the response
/// returned by the redirected request is considered.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpTarget {
/// Required. The full URI path that the request will be sent to. This string
/// must begin with either "<http://"> or "<https://".> Some examples of
/// valid values for \[uri][google.cloud.scheduler.v1.HttpTarget.uri\] are:
/// `<http://acme.com`> and `<https://acme.com/sales:8080`.> Cloud Scheduler will
/// encode some characters for safety and compatibility. The maximum allowed
/// URL length is 2083 characters after encoding.
#[prost(string, tag = "1")]
pub uri: ::prost::alloc::string::String,
/// Which HTTP method to use for the request.
#[prost(enumeration = "HttpMethod", tag = "2")]
pub http_method: i32,
/// The user can specify HTTP request headers to send with the job's
/// HTTP request. This map contains the header field names and
/// values. Repeated headers are not supported, but a header value can
/// contain commas. These headers represent a subset of the headers
/// that will accompany the job's HTTP request. Some HTTP request
/// headers will be ignored or replaced. A partial list of headers that
/// will be ignored or replaced is below:
/// - Host: This will be computed by Cloud Scheduler and derived from
/// \[uri][google.cloud.scheduler.v1.HttpTarget.uri\].
/// * `Content-Length`: This will be computed by Cloud Scheduler.
/// * `User-Agent`: This will be set to `"Google-Cloud-Scheduler"`.
/// * `X-Google-*`: Google internal use only.
/// * `X-AppEngine-*`: Google internal use only.
///
/// The total size of headers must be less than 80KB.
#[prost(map = "string, string", tag = "3")]
pub headers: ::std::collections::HashMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
/// HTTP request body. A request body is allowed only if the HTTP
/// method is POST, PUT, or PATCH. It is an error to set body on a job with an
/// incompatible \[HttpMethod][google.cloud.scheduler.v1.HttpMethod\].
#[prost(bytes = "vec", tag = "4")]
pub body: ::prost::alloc::vec::Vec<u8>,
/// The mode for generating an `Authorization` header for HTTP requests.
///
/// If specified, all `Authorization` headers in the \[HttpTarget.headers][google.cloud.scheduler.v1.HttpTarget.headers\]
/// field will be overridden.
#[prost(oneof = "http_target::AuthorizationHeader", tags = "5, 6")]
pub authorization_header: ::core::option::Option<http_target::AuthorizationHeader>,
}
/// Nested message and enum types in `HttpTarget`.
pub mod http_target {
/// The mode for generating an `Authorization` header for HTTP requests.
///
/// If specified, all `Authorization` headers in the \[HttpTarget.headers][google.cloud.scheduler.v1.HttpTarget.headers\]
/// field will be overridden.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum AuthorizationHeader {
/// If specified, an
/// [OAuth token](<https://developers.google.com/identity/protocols/OAuth2>)
/// will be generated and attached as an `Authorization` header in the HTTP
/// request.
///
/// This type of authorization should generally only be used when calling
/// Google APIs hosted on *.googleapis.com.
#[prost(message, tag = "5")]
OauthToken(super::OAuthToken),
/// If specified, an
/// \[OIDC\](<https://developers.google.com/identity/protocols/OpenIDConnect>)
/// token will be generated and attached as an `Authorization` header in the
/// HTTP request.
///
/// This type of authorization can be used for many scenarios, including
/// calling Cloud Run, or endpoints where you intend to validate the token
/// yourself.
#[prost(message, tag = "6")]
OidcToken(super::OidcToken),
}
}
/// App Engine target. The job will be pushed to a job handler by means
/// of an HTTP request via an \[http_method][google.cloud.scheduler.v1.AppEngineHttpTarget.http_method\] such
/// as HTTP POST, HTTP GET, etc. The job is acknowledged by means of an
/// HTTP response code in the range [200 - 299]. Error 503 is
/// considered an App Engine system error instead of an application
/// error. Requests returning error 503 will be retried regardless of
/// retry configuration and not counted against retry counts. Any other
/// response code, or a failure to receive a response before the
/// deadline, constitutes a failed attempt.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AppEngineHttpTarget {
/// The HTTP method to use for the request. PATCH and OPTIONS are not
/// permitted.
#[prost(enumeration = "HttpMethod", tag = "1")]
pub http_method: i32,
/// App Engine Routing setting for the job.
#[prost(message, optional, tag = "2")]
pub app_engine_routing: ::core::option::Option<AppEngineRouting>,
/// The relative URI.
///
/// The relative URL must begin with "/" and must be a valid HTTP relative URL.
/// It can contain a path, query string arguments, and `#` fragments.
/// If the relative URL is empty, then the root path "/" will be used.
/// No spaces are allowed, and the maximum length allowed is 2083 characters.
#[prost(string, tag = "3")]
pub relative_uri: ::prost::alloc::string::String,
/// HTTP request headers.
///
/// This map contains the header field names and values. Headers can be set
/// when the job is created.
///
/// Cloud Scheduler sets some headers to default values:
///
/// * `User-Agent`: By default, this header is
/// `"AppEngine-Google; (+<http://code.google.com/appengine>)"`.
/// This header can be modified, but Cloud Scheduler will append
/// `"AppEngine-Google; (+<http://code.google.com/appengine>)"` to the
/// modified `User-Agent`.
/// * `X-CloudScheduler`: This header will be set to true.
///
/// If the job has an \[body][google.cloud.scheduler.v1.AppEngineHttpTarget.body\], Cloud Scheduler sets
/// the following headers:
///
/// * `Content-Type`: By default, the `Content-Type` header is set to
/// `"application/octet-stream"`. The default can be overridden by explictly
/// setting `Content-Type` to a particular media type when the job is
/// created.
/// For example, `Content-Type` can be set to `"application/json"`.
/// * `Content-Length`: This is computed by Cloud Scheduler. This value is
/// output only. It cannot be changed.
///
/// The headers below are output only. They cannot be set or overridden:
///
/// * `X-Google-*`: For Google internal use only.
/// * `X-AppEngine-*`: For Google internal use only.
///
/// In addition, some App Engine headers, which contain
/// job-specific information, are also be sent to the job handler.
#[prost(map = "string, string", tag = "4")]
pub headers: ::std::collections::HashMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
/// Body.
///
/// HTTP request body. A request body is allowed only if the HTTP method is
/// POST or PUT. It will result in invalid argument error to set a body on a
/// job with an incompatible \[HttpMethod][google.cloud.scheduler.v1.HttpMethod\].
#[prost(bytes = "vec", tag = "5")]
pub body: ::prost::alloc::vec::Vec<u8>,
}
/// Pub/Sub target. The job will be delivered by publishing a message to
/// the given Pub/Sub topic.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PubsubTarget {
/// Required. The name of the Cloud Pub/Sub topic to which messages will
/// be published when a job is delivered. The topic name must be in the
/// same format as required by PubSub's
/// \[PublishRequest.name\](<https://cloud.google.com/pubsub/docs/reference/rpc/google.pubsub.v1#publishrequest>),
/// for example `projects/PROJECT_ID/topics/TOPIC_ID`.
///
/// The topic must be in the same project as the Cloud Scheduler job.
#[prost(string, tag = "1")]
pub topic_name: ::prost::alloc::string::String,
/// The message payload for PubsubMessage.
///
/// Pubsub message must contain either non-empty data, or at least one
/// attribute.
#[prost(bytes = "vec", tag = "3")]
pub data: ::prost::alloc::vec::Vec<u8>,
/// Attributes for PubsubMessage.
///
/// Pubsub message must contain either non-empty data, or at least one
/// attribute.
#[prost(map = "string, string", tag = "4")]
pub attributes: ::std::collections::HashMap<
::prost::alloc::string::String,
::prost::alloc::string::String,
>,
}
/// App Engine Routing.
///
/// For more information about services, versions, and instances see
/// [An Overview of App
/// Engine](<https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine>),
/// [Microservices Architecture on Google App
/// Engine](<https://cloud.google.com/appengine/docs/python/microservices-on-app-engine>),
/// [App Engine Standard request
/// routing](<https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed>),
/// and [App Engine Flex request
/// routing](<https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed>).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AppEngineRouting {
/// App service.
///
/// By default, the job is sent to the service which is the default
/// service when the job is attempted.
#[prost(string, tag = "1")]
pub service: ::prost::alloc::string::String,
/// App version.
///
/// By default, the job is sent to the version which is the default
/// version when the job is attempted.
#[prost(string, tag = "2")]
pub version: ::prost::alloc::string::String,
/// App instance.
///
/// By default, the job is sent to an instance which is available when
/// the job is attempted.
///
/// Requests can only be sent to a specific instance if
/// [manual scaling is used in App Engine
/// Standard](<https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine?hl=en_US#scaling_types_and_instance_classes>).
/// App Engine Flex does not support instances. For more information, see
/// [App Engine Standard request
/// routing](<https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed>)
/// and [App Engine Flex request
/// routing](<https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed>).
#[prost(string, tag = "3")]
pub instance: ::prost::alloc::string::String,
/// Output only. The host that the job is sent to.
///
/// For more information about how App Engine requests are routed, see
/// \[here\](<https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed>).
///
/// The host is constructed as:
///
///
/// * `host = \[application_domain_name\]`</br>
/// `| \[service\] + '.' + \[application_domain_name\]`</br>
/// `| \[version\] + '.' + \[application_domain_name\]`</br>
/// `| \[version_dot_service\]+ '.' + \[application_domain_name\]`</br>
/// `| \[instance\] + '.' + \[application_domain_name\]`</br>
/// `| \[instance_dot_service\] + '.' + \[application_domain_name\]`</br>
/// `| \[instance_dot_version\] + '.' + \[application_domain_name\]`</br>
/// `| \[instance_dot_version_dot_service\] + '.' + \[application_domain_name\]`
///
/// * `application_domain_name` = The domain name of the app, for
/// example <app-id>.appspot.com, which is associated with the
/// job's project ID.
///
/// * `service =` \[service][google.cloud.scheduler.v1.AppEngineRouting.service\]
///
/// * `version =` \[version][google.cloud.scheduler.v1.AppEngineRouting.version\]
///
/// * `version_dot_service =`
/// \[version][google.cloud.scheduler.v1.AppEngineRouting.version\] `+ '.' +`
/// \[service][google.cloud.scheduler.v1.AppEngineRouting.service\]
///
/// * `instance =` \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\]
///
/// * `instance_dot_service =`
/// \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\] `+ '.' +`
/// \[service][google.cloud.scheduler.v1.AppEngineRouting.service\]
///
/// * `instance_dot_version =`
/// \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\] `+ '.' +`
/// \[version][google.cloud.scheduler.v1.AppEngineRouting.version\]
///
/// * `instance_dot_version_dot_service =`
/// \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\] `+ '.' +`
/// \[version][google.cloud.scheduler.v1.AppEngineRouting.version\] `+ '.' +`
/// \[service][google.cloud.scheduler.v1.AppEngineRouting.service\]
///
///
/// If \[service][google.cloud.scheduler.v1.AppEngineRouting.service\] is empty, then the job will be sent
/// to the service which is the default service when the job is attempted.
///
/// If \[version][google.cloud.scheduler.v1.AppEngineRouting.version\] is empty, then the job will be sent
/// to the version which is the default version when the job is attempted.
///
/// If \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\] is empty, then the job will be
/// sent to an instance which is available when the job is attempted.
///
/// If \[service][google.cloud.scheduler.v1.AppEngineRouting.service\],
/// \[version][google.cloud.scheduler.v1.AppEngineRouting.version\], or
/// \[instance][google.cloud.scheduler.v1.AppEngineRouting.instance\] is invalid, then the job will be sent
/// to the default version of the default service when the job is attempted.
#[prost(string, tag = "4")]
pub host: ::prost::alloc::string::String,
}
/// Contains information needed for generating an
/// [OAuth token](<https://developers.google.com/identity/protocols/OAuth2>).
/// This type of authorization should generally only be used when calling Google
/// APIs hosted on *.googleapis.com.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OAuthToken {
/// [Service account email](<https://cloud.google.com/iam/docs/service-accounts>)
/// to be used for generating OAuth token.
/// The service account must be within the same project as the job. The caller
/// must have iam.serviceAccounts.actAs permission for the service account.
#[prost(string, tag = "1")]
pub service_account_email: ::prost::alloc::string::String,
/// OAuth scope to be used for generating OAuth access token.
/// If not specified, "<https://www.googleapis.com/auth/cloud-platform">
/// will be used.
#[prost(string, tag = "2")]
pub scope: ::prost::alloc::string::String,
}
/// Contains information needed for generating an
/// [OpenID Connect
/// token](<https://developers.google.com/identity/protocols/OpenIDConnect>).
/// This type of authorization can be used for many scenarios, including
/// calling Cloud Run, or endpoints where you intend to validate the token
/// yourself.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OidcToken {
/// [Service account email](<https://cloud.google.com/iam/docs/service-accounts>)
/// to be used for generating OIDC token.
/// The service account must be within the same project as the job. The caller
/// must have iam.serviceAccounts.actAs permission for the service account.
#[prost(string, tag = "1")]
pub service_account_email: ::prost::alloc::string::String,
/// Audience to be used when generating OIDC token. If not specified, the URI
/// specified in target will be used.
#[prost(string, tag = "2")]
pub audience: ::prost::alloc::string::String,
}
/// The HTTP method used to execute the job.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum HttpMethod {
/// HTTP method unspecified. Defaults to POST.
Unspecified = 0,
/// HTTP POST
Post = 1,
/// HTTP GET
Get = 2,
/// HTTP HEAD
Head = 3,
/// HTTP PUT
Put = 4,
/// HTTP DELETE
Delete = 5,
/// HTTP PATCH
Patch = 6,
/// HTTP OPTIONS
Options = 7,
}
impl HttpMethod {
/// String value of the enum field names used in the ProtoBuf definition.
///
/// The values are not transformed in any way and thus are considered stable
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
pub fn as_str_name(&self) -> &'static str {
match self {
HttpMethod::Unspecified => "HTTP_METHOD_UNSPECIFIED",
HttpMethod::Post => "POST",
HttpMethod::Get => "GET",
HttpMethod::Head => "HEAD",
HttpMethod::Put => "PUT",
HttpMethod::Delete => "DELETE",
HttpMethod::Patch => "PATCH",
HttpMethod::Options => "OPTIONS",
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"HTTP_METHOD_UNSPECIFIED" => Some(Self::Unspecified),
"POST" => Some(Self::Post),
"GET" => Some(Self::Get),
"HEAD" => Some(Self::Head),
"PUT" => Some(Self::Put),
"DELETE" => Some(Self::Delete),
"PATCH" => Some(Self::Patch),
"OPTIONS" => Some(Self::Options),
_ => None,
}
}
}
/// Configuration for a job.
/// The maximum allowed size for a job is 100KB.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
/// Optionally caller-specified in \[CreateJob][google.cloud.scheduler.v1.CloudScheduler.CreateJob\], after
/// which it becomes output only.
///
/// The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
///
/// * `PROJECT_ID` can contain letters (\[A-Za-z\]), numbers (\[0-9\]),
/// hyphens (-), colons (:), or periods (.).
/// For more information, see
/// [Identifying
/// projects](<https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects>)
/// * `LOCATION_ID` is the canonical ID for the job's location.
/// The list of available locations can be obtained by calling
/// \[ListLocations][google.cloud.location.Locations.ListLocations\].
/// For more information, see <https://cloud.google.com/about/locations/.>
/// * `JOB_ID` can contain only letters (\[A-Za-z\]), numbers (\[0-9\]),
/// hyphens (-), or underscores (_). The maximum length is 500 characters.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Optionally caller-specified in \[CreateJob][google.cloud.scheduler.v1.CloudScheduler.CreateJob\] or
/// \[UpdateJob][google.cloud.scheduler.v1.CloudScheduler.UpdateJob\].
///
/// A human-readable description for the job. This string must not contain
/// more than 500 characters.
#[prost(string, tag = "2")]
pub description: ::prost::alloc::string::String,
/// Required, except when used with \[UpdateJob][google.cloud.scheduler.v1.CloudScheduler.UpdateJob\].
///
/// Describes the schedule on which the job will be executed.
///
/// The schedule can be either of the following types:
///
/// * \[Crontab\](<http://en.wikipedia.org/wiki/Cron#Overview>)
/// * English-like
/// \[schedule\](<https://cloud.google.com/scheduler/docs/configuring/cron-job-schedules>)
///
/// As a general rule, execution `n + 1` of a job will not begin
/// until execution `n` has finished. Cloud Scheduler will never
/// allow two simultaneously outstanding executions. For example,
/// this implies that if the `n+1`th execution is scheduled to run at
/// 16:00 but the `n`th execution takes until 16:15, the `n+1`th
/// execution will not start until `16:15`.
/// A scheduled start time will be delayed if the previous
/// execution has not ended when its scheduled time occurs.
///
/// If \[retry_count][google.cloud.scheduler.v1.RetryConfig.retry_count\] > 0 and a job attempt fails,
/// the job will be tried a total of \[retry_count][google.cloud.scheduler.v1.RetryConfig.retry_count\]
/// times, with exponential backoff, until the next scheduled start
/// time.
#[prost(string, tag = "20")]
pub schedule: ::prost::alloc::string::String,
/// Specifies the time zone to be used in interpreting
/// \[schedule][google.cloud.scheduler.v1.Job.schedule\]. The value of this field must be a time
/// zone name from the [tz database](<http://en.wikipedia.org/wiki/Tz_database>).
///
/// Note that some time zones include a provision for
/// daylight savings time. The rules for daylight saving time are
/// determined by the chosen tz. For UTC use the string "utc". If a
/// time zone is not specified, the default will be in UTC (also known
/// as GMT).
#[prost(string, tag = "21")]
pub time_zone: ::prost::alloc::string::String,
/// Output only. The creation time of the job.
#[prost(message, optional, tag = "9")]
pub user_update_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. State of the job.
#[prost(enumeration = "job::State", tag = "10")]
pub state: i32,
/// Output only. The response from the target for the last attempted execution.
#[prost(message, optional, tag = "11")]
pub status: ::core::option::Option<super::super::super::rpc::Status>,
/// Output only. The next time the job is scheduled. Note that this may be a
/// retry of a previously failed attempt or the next execution time
/// according to the schedule.
#[prost(message, optional, tag = "17")]
pub schedule_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. The time the last job attempt started.
#[prost(message, optional, tag = "18")]
pub last_attempt_time: ::core::option::Option<::prost_types::Timestamp>,
/// Settings that determine the retry behavior.
#[prost(message, optional, tag = "19")]
pub retry_config: ::core::option::Option<RetryConfig>,
/// The deadline for job attempts. If the request handler does not respond by
/// this deadline then the request is cancelled and the attempt is marked as a
/// `DEADLINE_EXCEEDED` failure. The failed attempt can be viewed in
/// execution logs. Cloud Scheduler will retry the job according
/// to the \[RetryConfig][google.cloud.scheduler.v1.RetryConfig\].
///
/// The allowed duration for this deadline is:
/// * For [HTTP targets]\[google.cloud.scheduler.v1.Job.http_target\], between 15 seconds and 30 minutes.
/// * For [App Engine HTTP targets]\[google.cloud.scheduler.v1.Job.app_engine_http_target\], between 15
/// seconds and 24 hours.
#[prost(message, optional, tag = "22")]
pub attempt_deadline: ::core::option::Option<::prost_types::Duration>,
/// Required.
///
/// Delivery settings containing destination and parameters.
#[prost(oneof = "job::Target", tags = "4, 5, 6")]
pub target: ::core::option::Option<job::Target>,
}
/// Nested message and enum types in `Job`.
pub mod job {
/// State of the job.
#[derive(
Clone,
Copy,
Debug,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
::prost::Enumeration
)]
#[repr(i32)]
pub enum State {
/// Unspecified state.
Unspecified = 0,
/// The job is executing normally.
Enabled = 1,
/// The job is paused by the user. It will not execute. A user can
/// intentionally pause the job using
/// \[PauseJobRequest][google.cloud.scheduler.v1.PauseJobRequest\].
Paused = 2,
/// The job is disabled by the system due to error. The user
/// cannot directly set a job to be disabled.
Disabled = 3,
/// The job state resulting from a failed \[CloudScheduler.UpdateJob][google.cloud.scheduler.v1.CloudScheduler.UpdateJob\]
/// operation. To recover a job from this state, retry
/// \[CloudScheduler.UpdateJob][google.cloud.scheduler.v1.CloudScheduler.UpdateJob\] until a successful response is received.
UpdateFailed = 4,
}
impl State {
/// String value of the enum field names used in the ProtoBuf definition.
///
/// The values are not transformed in any way and thus are considered stable
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
pub fn as_str_name(&self) -> &'static str {
match self {
State::Unspecified => "STATE_UNSPECIFIED",
State::Enabled => "ENABLED",
State::Paused => "PAUSED",
State::Disabled => "DISABLED",
State::UpdateFailed => "UPDATE_FAILED",
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"STATE_UNSPECIFIED" => Some(Self::Unspecified),
"ENABLED" => Some(Self::Enabled),
"PAUSED" => Some(Self::Paused),
"DISABLED" => Some(Self::Disabled),
"UPDATE_FAILED" => Some(Self::UpdateFailed),
_ => None,
}
}
}
/// Required.
///
/// Delivery settings containing destination and parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Target {
/// Pub/Sub target.
#[prost(message, tag = "4")]
PubsubTarget(super::PubsubTarget),
/// App Engine HTTP target.
#[prost(message, tag = "5")]
AppEngineHttpTarget(super::AppEngineHttpTarget),
/// HTTP target.
#[prost(message, tag = "6")]
HttpTarget(super::HttpTarget),
}
}
/// Settings that determine the retry behavior.
///
/// By default, if a job does not complete successfully (meaning that
/// an acknowledgement is not received from the handler, then it will be retried
/// with exponential backoff according to the settings in \[RetryConfig][google.cloud.scheduler.v1.RetryConfig\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RetryConfig {
/// The number of attempts that the system will make to run a job using the
/// exponential backoff procedure described by
/// \[max_doublings][google.cloud.scheduler.v1.RetryConfig.max_doublings\].
///
/// The default value of retry_count is zero.
///
/// If retry_count is zero, a job attempt will *not* be retried if
/// it fails. Instead the Cloud Scheduler system will wait for the
/// next scheduled execution time.
///
/// If retry_count is set to a non-zero number then Cloud Scheduler
/// will retry failed attempts, using exponential backoff,
/// retry_count times, or until the next scheduled execution time,
/// whichever comes first.
///
/// Values greater than 5 and negative values are not allowed.
#[prost(int32, tag = "1")]
pub retry_count: i32,
/// The time limit for retrying a failed job, measured from time when an
/// execution was first attempted. If specified with
/// \[retry_count][google.cloud.scheduler.v1.RetryConfig.retry_count\], the job will be retried until both
/// limits are reached.
///
/// The default value for max_retry_duration is zero, which means retry
/// duration is unlimited.
#[prost(message, optional, tag = "2")]
pub max_retry_duration: ::core::option::Option<::prost_types::Duration>,
/// The minimum amount of time to wait before retrying a job after
/// it fails.
///
/// The default value of this field is 5 seconds.
#[prost(message, optional, tag = "3")]
pub min_backoff_duration: ::core::option::Option<::prost_types::Duration>,
/// The maximum amount of time to wait before retrying a job after
/// it fails.
///
/// The default value of this field is 1 hour.
#[prost(message, optional, tag = "4")]
pub max_backoff_duration: ::core::option::Option<::prost_types::Duration>,
/// The time between retries will double `max_doublings` times.
///
/// A job's retry interval starts at
/// \[min_backoff_duration][google.cloud.scheduler.v1.RetryConfig.min_backoff_duration\], then doubles
/// `max_doublings` times, then increases linearly, and finally
/// retries retries at intervals of
/// \[max_backoff_duration][google.cloud.scheduler.v1.RetryConfig.max_backoff_duration\] up to
/// \[retry_count][google.cloud.scheduler.v1.RetryConfig.retry_count\] times.
///
/// For example, if \[min_backoff_duration][google.cloud.scheduler.v1.RetryConfig.min_backoff_duration\] is
/// 10s, \[max_backoff_duration][google.cloud.scheduler.v1.RetryConfig.max_backoff_duration\] is 300s, and
/// `max_doublings` is 3, then the a job will first be retried in 10s. The
/// retry interval will double three times, and then increase linearly by
/// 2^3 * 10s. Finally, the job will retry at intervals of
/// \[max_backoff_duration][google.cloud.scheduler.v1.RetryConfig.max_backoff_duration\] until the job has
/// been attempted \[retry_count][google.cloud.scheduler.v1.RetryConfig.retry_count\] times. Thus, the
/// requests will retry at 10s, 20s, 40s, 80s, 160s, 240s, 300s, 300s, ....
///
/// The default value of this field is 5.
#[prost(int32, tag = "5")]
pub max_doublings: i32,
}
/// Request message for listing jobs using \[ListJobs][google.cloud.scheduler.v1.CloudScheduler.ListJobs\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsRequest {
/// Required. The location name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Requested page size.
///
/// The maximum page size is 500. If unspecified, the page size will
/// be the maximum. Fewer jobs than requested might be returned,
/// even if more jobs exist; use next_page_token to determine if more
/// jobs exist.
#[prost(int32, tag = "5")]
pub page_size: i32,
/// A token identifying a page of results the server will return. To
/// request the first page results, page_token must be empty. To
/// request the next page of results, page_token must be the value of
/// \[next_page_token][google.cloud.scheduler.v1.ListJobsResponse.next_page_token\] returned from
/// the previous call to \[ListJobs][google.cloud.scheduler.v1.CloudScheduler.ListJobs\]. It is an error to
/// switch the value of \[filter][google.cloud.scheduler.v1.ListJobsRequest.filter\] or
/// \[order_by][google.cloud.scheduler.v1.ListJobsRequest.order_by\] while iterating through pages.
#[prost(string, tag = "6")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for listing jobs using \[ListJobs][google.cloud.scheduler.v1.CloudScheduler.ListJobs\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsResponse {
/// The list of jobs.
#[prost(message, repeated, tag = "1")]
pub jobs: ::prost::alloc::vec::Vec<Job>,
/// A token to retrieve next page of results. Pass this value in the
/// \[page_token][google.cloud.scheduler.v1.ListJobsRequest.page_token\] field in the subsequent call to
/// \[ListJobs][google.cloud.scheduler.v1.CloudScheduler.ListJobs\] to retrieve the next page of results.
/// If this is empty it indicates that there are no more results
/// through which to paginate.
///
/// The page token is valid for only 2 hours.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for \[GetJob][google.cloud.scheduler.v1.CloudScheduler.GetJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetJobRequest {
/// Required. The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for \[CreateJob][google.cloud.scheduler.v1.CloudScheduler.CreateJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateJobRequest {
/// Required. The location name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The job to add. The user can optionally specify a name for the
/// job in \[name][google.cloud.scheduler.v1.Job.name\]. \[name][google.cloud.scheduler.v1.Job.name\] cannot be the same as an
/// existing job. If a name is not specified then the system will
/// generate a random unique name that will be returned
/// (\[name][google.cloud.scheduler.v1.Job.name\]) in the response.
#[prost(message, optional, tag = "2")]
pub job: ::core::option::Option<Job>,
}
/// Request message for \[UpdateJob][google.cloud.scheduler.v1.CloudScheduler.UpdateJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateJobRequest {
/// Required. The new job properties. \[name][google.cloud.scheduler.v1.Job.name\] must be specified.
///
/// Output only fields cannot be modified using UpdateJob.
/// Any value specified for an output only field will be ignored.
#[prost(message, optional, tag = "1")]
pub job: ::core::option::Option<Job>,
/// A mask used to specify which fields of the job are being updated.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for deleting a job using
/// \[DeleteJob][google.cloud.scheduler.v1.CloudScheduler.DeleteJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteJobRequest {
/// Required. The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for \[PauseJob][google.cloud.scheduler.v1.CloudScheduler.PauseJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PauseJobRequest {
/// Required. The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for \[ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResumeJobRequest {
/// Required. The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for forcing a job to run now using
/// \[RunJob][google.cloud.scheduler.v1.CloudScheduler.RunJob\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunJobRequest {
/// Required. The job name. For example:
/// `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod cloud_scheduler_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
/// The Cloud Scheduler API allows external entities to reliably
/// schedule asynchronous jobs.
#[derive(Debug, Clone)]
pub struct CloudSchedulerClient<T> {
inner: tonic::client::Grpc<T>,
}
impl CloudSchedulerClient<tonic::transport::Channel> {
/// Attempt to create a new client by connecting to a given endpoint.
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> CloudSchedulerClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_origin(inner: T, origin: Uri) -> Self {
let inner = tonic::client::Grpc::with_origin(inner, origin);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> CloudSchedulerClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
>>::Error: Into<StdError> + Send + Sync,
{
CloudSchedulerClient::new(InterceptedService::new(inner, interceptor))
}
/// Compress requests with the given encoding.
///
/// This requires the server to support it otherwise it might respond with an
/// error.
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
/// Enable decompressing responses.
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
/// Lists jobs.
pub async fn list_jobs(
&mut self,
request: impl tonic::IntoRequest<super::ListJobsRequest>,
) -> Result<tonic::Response<super::ListJobsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/ListJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Gets a job.
pub async fn get_job(
&mut self,
request: impl tonic::IntoRequest<super::GetJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/GetJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Creates a job.
pub async fn create_job(
&mut self,
request: impl tonic::IntoRequest<super::CreateJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/CreateJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Updates a job.
///
/// If successful, the updated [Job][google.cloud.scheduler.v1.Job] is returned. If the job does
/// not exist, `NOT_FOUND` is returned.
///
/// If UpdateJob does not successfully return, it is possible for the
/// job to be in an [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED] state. A job in this state may
/// not be executed. If this happens, retry the UpdateJob request
/// until a successful response is received.
pub async fn update_job(
&mut self,
request: impl tonic::IntoRequest<super::UpdateJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/UpdateJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Deletes a job.
pub async fn delete_job(
&mut self,
request: impl tonic::IntoRequest<super::DeleteJobRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/DeleteJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Pauses a job.
///
/// If a job is paused then the system will stop executing the job
/// until it is re-enabled via [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The
/// state of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if paused it
/// will be set to [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]
/// to be paused.
pub async fn pause_job(
&mut self,
request: impl tonic::IntoRequest<super::PauseJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/PauseJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Resume a job.
///
/// This method reenables a job after it has been [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The
/// state of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state]; after calling this method it
/// will be set to [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job must be in
/// [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED] to be resumed.
pub async fn resume_job(
&mut self,
request: impl tonic::IntoRequest<super::ResumeJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/ResumeJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
/// Forces a job to run now.
///
/// When this method is called, Cloud Scheduler will dispatch the job, even
/// if the job is already running.
pub async fn run_job(
&mut self,
request: impl tonic::IntoRequest<super::RunJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.scheduler.v1.CloudScheduler/RunJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}