,
}
/// SSL configuration for a `DomainMapping` resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SslSettings {
/// ID of the `AuthorizedCertificate` resource configuring SSL for the
/// application. Clearing this field will remove SSL support.
///
/// By default, a managed certificate is automatically created for every
/// domain mapping. To omit SSL support or to configure SSL manually, specify
/// `SslManagementType.MANUAL` on a `CREATE` or `UPDATE` request. You must
/// be authorized to administer the `AuthorizedCertificate` resource to
/// manually map it to a `DomainMapping` resource.
/// Example: `12345`.
#[prost(string, tag = "1")]
pub certificate_id: ::prost::alloc::string::String,
/// SSL management type for this domain. If `AUTOMATIC`, a managed certificate
/// is automatically provisioned. If `MANUAL`, `certificate_id` must be
/// manually specified in order to configure SSL for this domain.
#[prost(enumeration = "ssl_settings::SslManagementType", tag = "3")]
pub ssl_management_type: i32,
/// ID of the managed `AuthorizedCertificate` resource currently being
/// provisioned, if applicable. Until the new managed certificate has been
/// successfully provisioned, the previous SSL state will be preserved. Once
/// the provisioning process completes, the `certificate_id` field will reflect
/// the new managed certificate and this field will be left empty. To remove
/// SSL support while there is still a pending managed certificate, clear the
/// `certificate_id` field with an `UpdateDomainMappingRequest`.
///
/// @OutputOnly
#[prost(string, tag = "4")]
pub pending_managed_certificate_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `SslSettings`.
pub mod ssl_settings {
/// The SSL management type for this domain.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SslManagementType {
/// SSL support for this domain is configured automatically. The mapped SSL
/// certificate will be automatically renewed.
Automatic = 0,
/// SSL support for this domain is configured manually by the user. Either
/// the domain has no SSL support or a user-obtained SSL certificate has been
/// explictly mapped to this domain.
Manual = 1,
}
}
/// A DNS resource record.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourceRecord {
/// Relative name of the object affected by this record. Only applicable for
/// `CNAME` records. Example: 'www'.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Data for this record. Values vary by record type, as defined in RFC 1035
/// (section 5) and RFC 1034 (section 3.6.1).
#[prost(string, tag = "2")]
pub rrdata: ::prost::alloc::string::String,
/// Resource record type. Example: `AAAA`.
#[prost(enumeration = "resource_record::RecordType", tag = "3")]
pub r#type: i32,
}
/// Nested message and enum types in `ResourceRecord`.
pub mod resource_record {
/// A resource record type.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RecordType {
/// An A resource record. Data is an IPv4 address.
A = 0,
/// An AAAA resource record. Data is an IPv6 address.
Aaaa = 1,
/// A CNAME resource record. Data is a domain name to be aliased.
Cname = 2,
}
}
/// A single firewall rule that is evaluated against incoming traffic
/// and provides an action to take on matched requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FirewallRule {
/// A positive integer between [1, Int32.MaxValue-1] that defines the order of
/// rule evaluation. Rules with the lowest priority are evaluated first.
///
/// A default rule at priority Int32.MaxValue matches all IPv4 and IPv6 traffic
/// when no previous rule matches. Only the action of this rule can be modified
/// by the user.
#[prost(int32, tag = "1")]
pub priority: i32,
/// The action to take on matched requests.
#[prost(enumeration = "firewall_rule::Action", tag = "2")]
pub action: i32,
/// IP address or range, defined using CIDR notation, of requests that this
/// rule applies to. You can use the wildcard character "*" to match all IPs
/// equivalent to "0/0" and "::/0" together.
/// Examples: `192.168.1.1` or `192.168.0.0/16` or `2001:db8::/32`
/// or `2001:0db8:0000:0042:0000:8a2e:0370:7334`.
///
///
/// Truncation will be silently performed on addresses which are not
/// properly truncated. For example, `1.2.3.4/24` is accepted as the same
/// address as `1.2.3.0/24`. Similarly, for IPv6, `2001:db8::1/32` is accepted
/// as the same address as `2001:db8::/32`.
#[prost(string, tag = "3")]
pub source_range: ::prost::alloc::string::String,
/// An optional string description of this rule.
/// This field has a maximum length of 100 characters.
#[prost(string, tag = "4")]
pub description: ::prost::alloc::string::String,
}
/// Nested message and enum types in `FirewallRule`.
pub mod firewall_rule {
/// Available actions to take on matching requests.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Action {
UnspecifiedAction = 0,
/// Matching requests are allowed.
Allow = 1,
/// Matching requests are denied.
Deny = 2,
}
}
/// An Instance resource is the computing unit that App Engine uses to
/// automatically scale an application.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Instance {
/// Output only. Full path to the Instance resource in the API.
/// Example: `apps/myapp/services/default/versions/v1/instances/instance-1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Output only. Relative name of the instance within the version.
/// Example: `instance-1`.
#[prost(string, tag = "2")]
pub id: ::prost::alloc::string::String,
/// Output only. App Engine release this instance is running on.
#[prost(string, tag = "3")]
pub app_engine_release: ::prost::alloc::string::String,
/// Output only. Availability of the instance.
#[prost(enumeration = "instance::Availability", tag = "4")]
pub availability: i32,
/// Output only. Name of the virtual machine where this instance lives. Only applicable
/// for instances in App Engine flexible environment.
#[prost(string, tag = "5")]
pub vm_name: ::prost::alloc::string::String,
/// Output only. Zone where the virtual machine is located. Only applicable for instances
/// in App Engine flexible environment.
#[prost(string, tag = "6")]
pub vm_zone_name: ::prost::alloc::string::String,
/// Output only. Virtual machine ID of this instance. Only applicable for instances in
/// App Engine flexible environment.
#[prost(string, tag = "7")]
pub vm_id: ::prost::alloc::string::String,
/// Output only. Time that this instance was started.
///
/// @OutputOnly
#[prost(message, optional, tag = "8")]
pub start_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. Number of requests since this instance was started.
#[prost(int32, tag = "9")]
pub requests: i32,
/// Output only. Number of errors since this instance was started.
#[prost(int32, tag = "10")]
pub errors: i32,
/// Output only. Average queries per second (QPS) over the last minute.
#[prost(float, tag = "11")]
pub qps: f32,
/// Output only. Average latency (ms) over the last minute.
#[prost(int32, tag = "12")]
pub average_latency: i32,
/// Output only. Total memory in use (bytes).
#[prost(int64, tag = "13")]
pub memory_usage: i64,
/// Output only. Status of the virtual machine where this instance lives. Only applicable
/// for instances in App Engine flexible environment.
#[prost(string, tag = "14")]
pub vm_status: ::prost::alloc::string::String,
/// Output only. Whether this instance is in debug mode. Only applicable for instances in
/// App Engine flexible environment.
#[prost(bool, tag = "15")]
pub vm_debug_enabled: bool,
/// Output only. The IP address of this instance. Only applicable for instances in App
/// Engine flexible environment.
#[prost(string, tag = "16")]
pub vm_ip: ::prost::alloc::string::String,
/// Output only. The liveness health check of this instance. Only applicable for instances
/// in App Engine flexible environment.
#[prost(enumeration = "instance::liveness::LivenessState", tag = "17")]
pub vm_liveness: i32,
}
/// Nested message and enum types in `Instance`.
pub mod instance {
/// Wrapper for LivenessState enum.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Liveness {}
/// Nested message and enum types in `Liveness`.
pub mod liveness {
/// Liveness health check status for Flex instances.
#[derive(
Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
)]
#[repr(i32)]
pub enum LivenessState {
/// There is no liveness health check for the instance. Only applicable for
/// instances in App Engine standard environment.
Unspecified = 0,
/// The health checking system is aware of the instance but its health is
/// not known at the moment.
Unknown = 1,
/// The instance is reachable i.e. a connection to the application health
/// checking endpoint can be established, and conforms to the requirements
/// defined by the health check.
Healthy = 2,
/// The instance is reachable, but does not conform to the requirements
/// defined by the health check.
Unhealthy = 3,
/// The instance is being drained. The existing connections to the instance
/// have time to complete, but the new ones are being refused.
Draining = 4,
/// The instance is unreachable i.e. a connection to the application health
/// checking endpoint cannot be established, or the server does not respond
/// within the specified timeout.
Timeout = 5,
}
}
/// Availability of the instance.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Availability {
Unspecified = 0,
Resident = 1,
Dynamic = 2,
}
}
/// Code and application artifacts used to deploy a version to App Engine.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Deployment {
/// Manifest of the files stored in Google Cloud Storage that are included
/// as part of this version. All files must be readable using the
/// credentials supplied with this call.
#[prost(map = "string, message", tag = "1")]
pub files: ::std::collections::HashMap<::prost::alloc::string::String, FileInfo>,
/// The Docker image for the container that runs the version.
/// Only applicable for instances running in the App Engine flexible environment.
#[prost(message, optional, tag = "2")]
pub container: ::core::option::Option,
/// The zip file for this deployment, if this is a zip deployment.
#[prost(message, optional, tag = "3")]
pub zip: ::core::option::Option,
/// Google Cloud Build build information. Only applicable for instances running
/// in the App Engine flexible environment.
#[prost(message, optional, tag = "5")]
pub build: ::core::option::Option,
/// Options for any Google Cloud Build builds created as a part of this
/// deployment.
///
/// These options will only be used if a new build is created, such as when
/// deploying to the App Engine flexible environment using files or zip.
#[prost(message, optional, tag = "6")]
pub cloud_build_options: ::core::option::Option,
}
/// Single source file that is part of the version to be deployed. Each source
/// file that is deployed must be specified separately.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileInfo {
/// URL source to use to fetch this file. Must be a URL to a resource in
/// Google Cloud Storage in the form
/// 'http(s)://storage.googleapis.com/\/\'.
#[prost(string, tag = "1")]
pub source_url: ::prost::alloc::string::String,
/// The SHA1 hash of the file, in hex.
#[prost(string, tag = "2")]
pub sha1_sum: ::prost::alloc::string::String,
/// The MIME type of the file.
///
/// Defaults to the value from Google Cloud Storage.
#[prost(string, tag = "3")]
pub mime_type: ::prost::alloc::string::String,
}
/// Docker image that is used to create a container and start a VM instance for
/// the version that you deploy. Only applicable for instances running in the App
/// Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContainerInfo {
/// URI to the hosted container image in Google Container Registry. The URI
/// must be fully qualified and include a tag or digest.
/// Examples: "gcr.io/my-project/image:tag" or "gcr.io/my-project/image@digest"
#[prost(string, tag = "1")]
pub image: ::prost::alloc::string::String,
}
/// Google Cloud Build information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BuildInfo {
/// The Google Cloud Build id.
/// Example: "f966068f-08b2-42c8-bdfe-74137dff2bf9"
#[prost(string, tag = "1")]
pub cloud_build_id: ::prost::alloc::string::String,
}
/// Options for the build operations performed as a part of the version
/// deployment. Only applicable for App Engine flexible environment when creating
/// a version using source code directly.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudBuildOptions {
/// Path to the yaml file used in deployment, used to determine runtime
/// configuration details.
///
/// Required for flexible environment builds.
///
/// See
/// for more details.
#[prost(string, tag = "1")]
pub app_yaml_path: ::prost::alloc::string::String,
/// The Cloud Build timeout used as part of any dependent builds performed by
/// version creation. Defaults to 10 minutes.
#[prost(message, optional, tag = "2")]
pub cloud_build_timeout: ::core::option::Option<::prost_types::Duration>,
}
/// The zip file information for a zip deployment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ZipInfo {
/// URL of the zip file to deploy from. Must be a URL to a resource in
/// Google Cloud Storage in the form
/// 'http(s)://storage.googleapis.com/\/\'.
#[prost(string, tag = "3")]
pub source_url: ::prost::alloc::string::String,
/// An estimate of the number of files in a zip for a zip deployment.
/// If set, must be greater than or equal to the actual number of files.
/// Used for optimizing performance; if not provided, deployment may be slow.
#[prost(int32, tag = "4")]
pub files_count: i32,
}
/// A NetworkSettings resource is a container for ingress settings for a version
/// or service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NetworkSettings {
/// The ingress settings for version or service.
#[prost(enumeration = "network_settings::IngressTrafficAllowed", tag = "1")]
pub ingress_traffic_allowed: i32,
}
/// Nested message and enum types in `NetworkSettings`.
pub mod network_settings {
/// If unspecified, INGRESS_TRAFFIC_ALLOWED_ALL will be used.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IngressTrafficAllowed {
/// Unspecified
Unspecified = 0,
/// Allow HTTP traffic from public and private sources.
All = 1,
/// Allow HTTP traffic from only private VPC sources.
InternalOnly = 2,
/// Allow HTTP traffic from private VPC sources and through load balancers.
InternalAndLb = 3,
}
}
/// A Version resource is a specific set of source code and configuration files
/// that are deployed into a service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Version {
/// Full path to the Version resource in the API. Example:
/// `apps/myapp/services/default/versions/v1`.
///
/// @OutputOnly
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Relative name of the version within the service. Example: `v1`.
/// Version names can contain only lowercase letters, numbers, or hyphens.
/// Reserved names: "default", "latest", and any name with the prefix "ah-".
#[prost(string, tag = "2")]
pub id: ::prost::alloc::string::String,
/// Before an application can receive email or XMPP messages, the application
/// must be configured to enable the service.
#[prost(enumeration = "InboundServiceType", repeated, tag = "6")]
pub inbound_services: ::prost::alloc::vec::Vec,
/// Instance class that is used to run this version. Valid values are:
///
/// * AutomaticScaling: `F1`, `F2`, `F4`, `F4_1G`
/// * ManualScaling or BasicScaling: `B1`, `B2`, `B4`, `B8`, `B4_1G`
///
/// Defaults to `F1` for AutomaticScaling and `B1` for ManualScaling or
/// BasicScaling.
#[prost(string, tag = "7")]
pub instance_class: ::prost::alloc::string::String,
/// Extra network settings.
/// Only applicable in the App Engine flexible environment.
#[prost(message, optional, tag = "8")]
pub network: ::core::option::Option,
/// The Google Compute Engine zones that are supported by this version in the
/// App Engine flexible environment. Deprecated.
#[prost(string, repeated, tag = "118")]
pub zones: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Machine resources for this version.
/// Only applicable in the App Engine flexible environment.
#[prost(message, optional, tag = "9")]
pub resources: ::core::option::Option,
/// Desired runtime. Example: `python27`.
#[prost(string, tag = "10")]
pub runtime: ::prost::alloc::string::String,
/// The channel of the runtime to use. Only available for some
/// runtimes. Defaults to the `default` channel.
#[prost(string, tag = "117")]
pub runtime_channel: ::prost::alloc::string::String,
/// Whether multiple requests can be dispatched to this version at once.
#[prost(bool, tag = "11")]
pub threadsafe: bool,
/// Whether to deploy this version in a container on a virtual machine.
#[prost(bool, tag = "12")]
pub vm: bool,
/// app_engine_apis allows second generation runtimes to access the
/// App Engine APIs.
#[prost(bool, tag = "128")]
pub app_engine_apis: bool,
/// Metadata settings that are supplied to this version to enable
/// beta runtime features.
#[prost(map = "string, string", tag = "13")]
pub beta_settings:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
/// App Engine execution environment for this version.
///
/// Defaults to `standard`.
#[prost(string, tag = "14")]
pub env: ::prost::alloc::string::String,
/// Current serving status of this version. Only the versions with a
/// `SERVING` status create instances and can be billed.
///
/// `SERVING_STATUS_UNSPECIFIED` is an invalid value. Defaults to `SERVING`.
#[prost(enumeration = "ServingStatus", tag = "15")]
pub serving_status: i32,
/// Email address of the user who created this version.
///
/// @OutputOnly
#[prost(string, tag = "16")]
pub created_by: ::prost::alloc::string::String,
/// Time that this version was created.
///
/// @OutputOnly
#[prost(message, optional, tag = "17")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
/// Total size in bytes of all the files that are included in this version
/// and currently hosted on the App Engine disk.
///
/// @OutputOnly
#[prost(int64, tag = "18")]
pub disk_usage_bytes: i64,
/// The version of the API in the given runtime environment. Please see the
/// app.yaml reference for valid values at
/// /config/appref>
#[prost(string, tag = "21")]
pub runtime_api_version: ::prost::alloc::string::String,
/// The path or name of the app's main executable.
#[prost(string, tag = "22")]
pub runtime_main_executable_path: ::prost::alloc::string::String,
/// The identity that the deployed version will run as.
/// Admin API will use the App Engine Appspot service account as default if
/// this field is neither provided in app.yaml file nor through CLI flag.
#[prost(string, tag = "127")]
pub service_account: ::prost::alloc::string::String,
/// An ordered list of URL-matching patterns that should be applied to incoming
/// requests. The first matching URL handles the request and other request
/// handlers are not attempted.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, repeated, tag = "100")]
pub handlers: ::prost::alloc::vec::Vec,
/// Custom static error pages. Limited to 10KB per page.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, repeated, tag = "101")]
pub error_handlers: ::prost::alloc::vec::Vec,
/// Configuration for third-party Python runtime libraries that are required
/// by the application.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, repeated, tag = "102")]
pub libraries: ::prost::alloc::vec::Vec,
/// Serving configuration for
/// [Google Cloud Endpoints]().
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "103")]
pub api_config: ::core::option::Option,
/// Environment variables available to the application.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(map = "string, string", tag = "104")]
pub env_variables:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
/// Environment variables available to the build environment.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(map = "string, string", tag = "125")]
pub build_env_variables:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
/// Duration that static files should be cached by web proxies and browsers.
/// Only applicable if the corresponding
/// \[StaticFilesHandler\]()
/// does not specify its own expiration time.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "105")]
pub default_expiration: ::core::option::Option<::prost_types::Duration>,
/// Configures health checking for instances. Unhealthy instances are
/// stopped and replaced with new instances.
/// Only applicable in the App Engine flexible environment.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "106")]
pub health_check: ::core::option::Option,
/// Configures readiness health checking for instances.
/// Unhealthy instances are not put into the backend traffic rotation.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "112")]
pub readiness_check: ::core::option::Option,
/// Configures liveness health checking for instances.
/// Unhealthy instances are stopped and replaced with new instances
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "113")]
pub liveness_check: ::core::option::Option,
/// Files that match this pattern will not be built into this version.
/// Only applicable for Go runtimes.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(string, tag = "107")]
pub nobuild_files_regex: ::prost::alloc::string::String,
/// Code and application artifacts that make up this version.
///
/// Only returned in `GET` requests if `view=FULL` is set.
#[prost(message, optional, tag = "108")]
pub deployment: ::core::option::Option,
/// Serving URL for this version. Example:
/// "
///
/// @OutputOnly
#[prost(string, tag = "109")]
pub version_url: ::prost::alloc::string::String,
/// Cloud Endpoints configuration.
///
/// If endpoints_api_service is set, the Cloud Endpoints Extensible Service
/// Proxy will be provided to serve the API implemented by the app.
#[prost(message, optional, tag = "110")]
pub endpoints_api_service: ::core::option::Option,
/// The entrypoint for the application.
#[prost(message, optional, tag = "122")]
pub entrypoint: ::core::option::Option,
/// Enables VPC connectivity for standard apps.
#[prost(message, optional, tag = "121")]
pub vpc_access_connector: ::core::option::Option,
/// Controls how instances are created, scaled, and reaped.
///
/// Defaults to `AutomaticScaling`.
#[prost(oneof = "version::Scaling", tags = "3, 4, 5")]
pub scaling: ::core::option::Option,
}
/// Nested message and enum types in `Version`.
pub mod version {
/// Controls how instances are created, scaled, and reaped.
///
/// Defaults to `AutomaticScaling`.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Scaling {
/// Automatic scaling is based on request rate, response latencies, and other
/// application metrics. Instances are dynamically created and destroyed as
/// needed in order to handle traffic.
#[prost(message, tag = "3")]
AutomaticScaling(super::AutomaticScaling),
/// A service with basic scaling will create an instance when the application
/// receives a request. The instance will be turned down when the app becomes
/// idle. Basic scaling is ideal for work that is intermittent or driven by
/// user activity.
#[prost(message, tag = "4")]
BasicScaling(super::BasicScaling),
/// A service with manual scaling runs continuously, allowing you to perform
/// complex initialization and rely on the state of its memory over time.
/// Manually scaled versions are sometimes referred to as "backends".
#[prost(message, tag = "5")]
ManualScaling(super::ManualScaling),
}
}
/// [Cloud Endpoints]() configuration.
/// The Endpoints API Service provides tooling for serving Open API and gRPC
/// endpoints via an NGINX proxy. Only valid for App Engine Flexible environment
/// deployments.
///
/// The fields here refer to the name and configuration ID of a "service"
/// resource in the [Service Management API]().
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointsApiService {
/// Endpoints service name which is the name of the "service" resource in the
/// Service Management API. For example "myapi.endpoints.myproject.cloud.goog"
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Endpoints service configuration ID as specified by the Service Management
/// API. For example "2016-09-19r1".
///
/// By default, the rollout strategy for Endpoints is `RolloutStrategy.FIXED`.
/// This means that Endpoints starts up with a particular configuration ID.
/// When a new configuration is rolled out, Endpoints must be given the new
/// configuration ID. The `config_id` field is used to give the configuration
/// ID and is required in this case.
///
/// Endpoints also has a rollout strategy called `RolloutStrategy.MANAGED`.
/// When using this, Endpoints fetches the latest configuration and does not
/// need the configuration ID. In this case, `config_id` must be omitted.
#[prost(string, tag = "2")]
pub config_id: ::prost::alloc::string::String,
/// Endpoints rollout strategy. If `FIXED`, `config_id` must be specified. If
/// `MANAGED`, `config_id` must be omitted.
#[prost(enumeration = "endpoints_api_service::RolloutStrategy", tag = "3")]
pub rollout_strategy: i32,
/// Enable or disable trace sampling. By default, this is set to false for
/// enabled.
#[prost(bool, tag = "4")]
pub disable_trace_sampling: bool,
}
/// Nested message and enum types in `EndpointsApiService`.
pub mod endpoints_api_service {
/// Available rollout strategies.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RolloutStrategy {
/// Not specified. Defaults to `FIXED`.
UnspecifiedRolloutStrategy = 0,
/// Endpoints service configuration ID will be fixed to the configuration ID
/// specified by `config_id`.
Fixed = 1,
/// Endpoints service configuration ID will be updated with each rollout.
Managed = 2,
}
}
/// Automatic scaling is based on request rate, response latencies, and other
/// application metrics.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutomaticScaling {
/// The time period that the
/// \[Autoscaler\]()
/// should wait before it starts collecting information from a new instance.
/// This prevents the autoscaler from collecting information when the instance
/// is initializing, during which the collected usage would not be reliable.
/// Only applicable in the App Engine flexible environment.
#[prost(message, optional, tag = "1")]
pub cool_down_period: ::core::option::Option<::prost_types::Duration>,
/// Target scaling by CPU usage.
#[prost(message, optional, tag = "2")]
pub cpu_utilization: ::core::option::Option,
/// Number of concurrent requests an automatic scaling instance can accept
/// before the scheduler spawns a new instance.
///
/// Defaults to a runtime-specific value.
#[prost(int32, tag = "3")]
pub max_concurrent_requests: i32,
/// Maximum number of idle instances that should be maintained for this
/// version.
#[prost(int32, tag = "4")]
pub max_idle_instances: i32,
/// Maximum number of instances that should be started to handle requests for
/// this version.
#[prost(int32, tag = "5")]
pub max_total_instances: i32,
/// Maximum amount of time that a request should wait in the pending queue
/// before starting a new instance to handle it.
#[prost(message, optional, tag = "6")]
pub max_pending_latency: ::core::option::Option<::prost_types::Duration>,
/// Minimum number of idle instances that should be maintained for
/// this version. Only applicable for the default version of a service.
#[prost(int32, tag = "7")]
pub min_idle_instances: i32,
/// Minimum number of running instances that should be maintained for this
/// version.
#[prost(int32, tag = "8")]
pub min_total_instances: i32,
/// Minimum amount of time a request should wait in the pending queue before
/// starting a new instance to handle it.
#[prost(message, optional, tag = "9")]
pub min_pending_latency: ::core::option::Option<::prost_types::Duration>,
/// Target scaling by request utilization.
#[prost(message, optional, tag = "10")]
pub request_utilization: ::core::option::Option,
/// Target scaling by disk usage.
#[prost(message, optional, tag = "11")]
pub disk_utilization: ::core::option::Option,
/// Target scaling by network usage.
#[prost(message, optional, tag = "12")]
pub network_utilization: ::core::option::Option,
/// Target scaling by user-provided metrics.
/// Only applicable in the App Engine flexible environment.
#[prost(message, repeated, tag = "21")]
pub custom_metrics: ::prost::alloc::vec::Vec,
/// Scheduler settings for standard environment.
#[prost(message, optional, tag = "20")]
pub standard_scheduler_settings: ::core::option::Option,
}
/// A service with basic scaling will create an instance when the application
/// receives a request. The instance will be turned down when the app becomes
/// idle. Basic scaling is ideal for work that is intermittent or driven by
/// user activity.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BasicScaling {
/// Duration of time after the last request that an instance must wait before
/// the instance is shut down.
#[prost(message, optional, tag = "1")]
pub idle_timeout: ::core::option::Option<::prost_types::Duration>,
/// Maximum number of instances to create for this version.
#[prost(int32, tag = "2")]
pub max_instances: i32,
}
/// A service with manual scaling runs continuously, allowing you to perform
/// complex initialization and rely on the state of its memory over time.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ManualScaling {
/// Number of instances to assign to the service at the start. This number
/// can later be altered by using the
/// [Modules API]()
/// `set_num_instances()` function.
#[prost(int32, tag = "1")]
pub instances: i32,
}
/// Target scaling by CPU usage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CpuUtilization {
/// Period of time over which CPU utilization is calculated.
#[prost(message, optional, tag = "1")]
pub aggregation_window_length: ::core::option::Option<::prost_types::Duration>,
/// Target CPU utilization ratio to maintain when scaling. Must be between 0
/// and 1.
#[prost(double, tag = "2")]
pub target_utilization: f64,
}
/// Target scaling by request utilization.
/// Only applicable in the App Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestUtilization {
/// Target requests per second.
#[prost(int32, tag = "1")]
pub target_request_count_per_second: i32,
/// Target number of concurrent requests.
#[prost(int32, tag = "2")]
pub target_concurrent_requests: i32,
}
/// Target scaling by disk usage.
/// Only applicable in the App Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DiskUtilization {
/// Target bytes written per second.
#[prost(int32, tag = "14")]
pub target_write_bytes_per_second: i32,
/// Target ops written per second.
#[prost(int32, tag = "15")]
pub target_write_ops_per_second: i32,
/// Target bytes read per second.
#[prost(int32, tag = "16")]
pub target_read_bytes_per_second: i32,
/// Target ops read per seconds.
#[prost(int32, tag = "17")]
pub target_read_ops_per_second: i32,
}
/// Target scaling by network usage.
/// Only applicable in the App Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NetworkUtilization {
/// Target bytes sent per second.
#[prost(int32, tag = "1")]
pub target_sent_bytes_per_second: i32,
/// Target packets sent per second.
#[prost(int32, tag = "11")]
pub target_sent_packets_per_second: i32,
/// Target bytes received per second.
#[prost(int32, tag = "12")]
pub target_received_bytes_per_second: i32,
/// Target packets received per second.
#[prost(int32, tag = "13")]
pub target_received_packets_per_second: i32,
}
/// Allows autoscaling based on Stackdriver metrics.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomMetric {
/// The name of the metric.
#[prost(string, tag = "1")]
pub metric_name: ::prost::alloc::string::String,
/// The type of the metric. Must be a string representing a Stackdriver
/// metric type e.g. GAGUE, DELTA_PER_SECOND, etc.
#[prost(string, tag = "2")]
pub target_type: ::prost::alloc::string::String,
/// Allows filtering on the metric's fields.
#[prost(string, tag = "5")]
pub filter: ::prost::alloc::string::String,
/// The target spec.
#[prost(oneof = "custom_metric::TargetSpec", tags = "3, 4")]
pub target_spec: ::core::option::Option,
}
/// Nested message and enum types in `CustomMetric`.
pub mod custom_metric {
/// The target spec.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum TargetSpec {
/// The target value for the metric.
#[prost(double, tag = "3")]
TargetUtilization(f64),
/// May be used instead of `target_utilization` when an instance can handle a
/// specific amount of work/resources and the metric value is equal to the
/// current amount of work remaining. The autoscaler will try to keep the
/// number of instances equal to the metric value divided by
/// `single_instance_assignment`.
#[prost(double, tag = "4")]
SingleInstanceAssignment(f64),
}
}
/// Scheduler settings for standard environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StandardSchedulerSettings {
/// Target CPU utilization ratio to maintain when scaling.
#[prost(double, tag = "1")]
pub target_cpu_utilization: f64,
/// Target throughput utilization ratio to maintain when scaling
#[prost(double, tag = "2")]
pub target_throughput_utilization: f64,
/// Minimum number of instances to run for this version. Set to zero to disable
/// `min_instances` configuration.
#[prost(int32, tag = "3")]
pub min_instances: i32,
/// Maximum number of instances to run for this version. Set to zero to disable
/// `max_instances` configuration.
#[prost(int32, tag = "4")]
pub max_instances: i32,
}
/// Extra network settings.
/// Only applicable in the App Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Network {
/// List of ports, or port pairs, to forward from the virtual machine to the
/// application container.
/// Only applicable in the App Engine flexible environment.
#[prost(string, repeated, tag = "1")]
pub forwarded_ports: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Tag to apply to the instance during creation.
/// Only applicable in the App Engine flexible environment.
#[prost(string, tag = "2")]
pub instance_tag: ::prost::alloc::string::String,
/// Google Compute Engine network where the virtual machines are created.
/// Specify the short name, not the resource path.
///
/// Defaults to `default`.
#[prost(string, tag = "3")]
pub name: ::prost::alloc::string::String,
/// Google Cloud Platform sub-network where the virtual machines are created.
/// Specify the short name, not the resource path.
///
/// If a subnetwork name is specified, a network name will also be required
/// unless it is for the default network.
///
/// * If the network that the instance is being created in is a Legacy network,
/// then the IP address is allocated from the IPv4Range.
/// * If the network that the instance is being created in is an auto Subnet
/// Mode Network, then only network name should be specified (not the
/// subnetwork_name) and the IP address is created from the IPCidrRange of the
/// subnetwork that exists in that zone for that network.
/// * If the network that the instance is being created in is a custom Subnet
/// Mode Network, then the subnetwork_name must be specified and the
/// IP address is created from the IPCidrRange of the subnetwork.
///
/// If specified, the subnetwork must exist in the same region as the
/// App Engine flexible environment application.
#[prost(string, tag = "4")]
pub subnetwork_name: ::prost::alloc::string::String,
/// Enable session affinity.
/// Only applicable in the App Engine flexible environment.
#[prost(bool, tag = "5")]
pub session_affinity: bool,
}
/// Volumes mounted within the app container.
/// Only applicable in the App Engine flexible environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Volume {
/// Unique name for the volume.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Underlying volume type, e.g. 'tmpfs'.
#[prost(string, tag = "2")]
pub volume_type: ::prost::alloc::string::String,
/// Volume size in gigabytes.
#[prost(double, tag = "3")]
pub size_gb: f64,
}
/// Machine resources for a version.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
/// Number of CPU cores needed.
#[prost(double, tag = "1")]
pub cpu: f64,
/// Disk size (GB) needed.
#[prost(double, tag = "2")]
pub disk_gb: f64,
/// Memory (GB) needed.
#[prost(double, tag = "3")]
pub memory_gb: f64,
/// User specified volumes.
#[prost(message, repeated, tag = "4")]
pub volumes: ::prost::alloc::vec::Vec,
/// The name of the encryption key that is stored in Google Cloud KMS.
/// Only should be used by Cloud Composer to encrypt the vm disk
#[prost(string, tag = "5")]
pub kms_key_reference: ::prost::alloc::string::String,
}
/// VPC access connector specification.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VpcAccessConnector {
/// Full Serverless VPC Access Connector name e.g.
/// /projects/my-project/locations/us-central1/connectors/c1.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// The entrypoint for the application.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Entrypoint {
/// The command to run.
#[prost(oneof = "entrypoint::Command", tags = "1")]
pub command: ::core::option::Option,
}
/// Nested message and enum types in `Entrypoint`.
pub mod entrypoint {
/// The command to run.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Command {
/// The format should be a shell command that can be fed to `bash -c`.
#[prost(string, tag = "1")]
Shell(::prost::alloc::string::String),
}
}
/// Available inbound services.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum InboundServiceType {
/// Not specified.
InboundServiceUnspecified = 0,
/// Allows an application to receive mail.
InboundServiceMail = 1,
/// Allows an application to receive email-bound notifications.
InboundServiceMailBounce = 2,
/// Allows an application to receive error stanzas.
InboundServiceXmppError = 3,
/// Allows an application to receive instant messages.
InboundServiceXmppMessage = 4,
/// Allows an application to receive user subscription POSTs.
InboundServiceXmppSubscribe = 5,
/// Allows an application to receive a user's chat presence.
InboundServiceXmppPresence = 6,
/// Registers an application for notifications when a client connects or
/// disconnects from a channel.
InboundServiceChannelPresence = 7,
/// Enables warmup requests.
InboundServiceWarmup = 9,
}
/// Run states of a version.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ServingStatus {
/// Not specified.
Unspecified = 0,
/// Currently serving. Instances are created according to the
/// scaling settings of the version.
Serving = 1,
/// Disabled. No instances will be created and the scaling
/// settings are ignored until the state of the version changes
/// to `SERVING`.
Stopped = 2,
}
/// A Service resource is a logical component of an application that can share
/// state and communicate in a secure fashion with other services.
/// For example, an application that handles customer requests might
/// include separate services to handle tasks such as backend data
/// analysis or API requests from mobile devices. Each service has a
/// collection of versions that define a specific set of code used to
/// implement the functionality of that service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
/// Full path to the Service resource in the API.
/// Example: `apps/myapp/services/default`.
///
/// @OutputOnly
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Relative name of the service within the application.
/// Example: `default`.
///
/// @OutputOnly
#[prost(string, tag = "2")]
pub id: ::prost::alloc::string::String,
/// Mapping that defines fractional HTTP traffic diversion to
/// different versions within the service.
#[prost(message, optional, tag = "3")]
pub split: ::core::option::Option,
/// Ingress settings for this service. Will apply to all versions.
#[prost(message, optional, tag = "6")]
pub network_settings: ::core::option::Option,
}
/// Traffic routing configuration for versions within a single service. Traffic
/// splits define how traffic directed to the service is assigned to versions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrafficSplit {
/// Mechanism used to determine which version a request is sent to.
/// The traffic selection algorithm will
/// be stable for either type until allocations are changed.
#[prost(enumeration = "traffic_split::ShardBy", tag = "1")]
pub shard_by: i32,
/// Mapping from version IDs within the service to fractional
/// (0.000, 1] allocations of traffic for that version. Each version can
/// be specified only once, but some versions in the service may not
/// have any traffic allocation. Services that have traffic allocated
/// cannot be deleted until either the service is deleted or
/// their traffic allocation is removed. Allocations must sum to 1.
/// Up to two decimal place precision is supported for IP-based splits and
/// up to three decimal places is supported for cookie-based splits.
#[prost(map = "string, double", tag = "2")]
pub allocations: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
}
/// Nested message and enum types in `TrafficSplit`.
pub mod traffic_split {
/// Available sharding mechanisms.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ShardBy {
/// Diversion method unspecified.
Unspecified = 0,
/// Diversion based on a specially named cookie, "GOOGAPPUID." The cookie
/// must be set by the application itself or no diversion will occur.
Cookie = 1,
/// Diversion based on applying the modulus operation to a fingerprint
/// of the IP address.
Ip = 2,
/// Diversion based on weighted random assignment. An incoming request is
/// randomly routed to a version in the traffic split, with probability
/// proportional to the version's traffic share.
Random = 3,
}
}
/// Request message for `Applications.GetApplication`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetApplicationRequest {
/// Name of the Application resource to get. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Applications.CreateApplication`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateApplicationRequest {
/// Application configuration.
#[prost(message, optional, tag = "2")]
pub application: ::core::option::Option,
}
/// Request message for `Applications.UpdateApplication`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateApplicationRequest {
/// Name of the Application resource to update. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// An Application containing the updated resource.
#[prost(message, optional, tag = "2")]
pub application: ::core::option::Option,
/// Standard field mask for the set of fields to be updated.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for 'Applications.RepairApplication'.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RepairApplicationRequest {
/// Name of the application to repair. Example: `apps/myapp`
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Services.ListServices`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServicesRequest {
/// Name of the parent Application resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `Services.ListServices`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServicesResponse {
/// The services belonging to the requested application.
#[prost(message, repeated, tag = "1")]
pub services: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `Services.GetService`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetServiceRequest {
/// Name of the resource requested. Example: `apps/myapp/services/default`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Services.UpdateService`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateServiceRequest {
/// Name of the resource to update. Example: `apps/myapp/services/default`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// A Service resource containing the updated service. Only fields set in the
/// field mask will be updated.
#[prost(message, optional, tag = "2")]
pub service: ::core::option::Option,
/// Standard field mask for the set of fields to be updated.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
/// Set to `true` to gradually shift traffic to one or more versions that you
/// specify. By default, traffic is shifted immediately.
/// For gradual traffic migration, the target versions
/// must be located within instances that are configured for both
/// [warmup requests]()
/// and
/// [automatic scaling]().
/// You must specify the
/// \[`shardBy`\]()
/// field in the Service resource. Gradual traffic migration is not
/// supported in the App Engine flexible environment. For examples, see
/// [Migrating and Splitting Traffic]().
#[prost(bool, tag = "4")]
pub migrate_traffic: bool,
}
/// Request message for `Services.DeleteService`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteServiceRequest {
/// Name of the resource requested. Example: `apps/myapp/services/default`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Versions.ListVersions`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVersionsRequest {
/// Name of the parent Service resource. Example:
/// `apps/myapp/services/default`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Controls the set of fields returned in the `List` response.
#[prost(enumeration = "VersionView", tag = "2")]
pub view: i32,
/// Maximum results to return per page.
#[prost(int32, tag = "3")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "4")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `Versions.ListVersions`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVersionsResponse {
/// The versions belonging to the requested service.
#[prost(message, repeated, tag = "1")]
pub versions: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `Versions.GetVersion`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVersionRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/services/default/versions/v1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Controls the set of fields returned in the `Get` response.
#[prost(enumeration = "VersionView", tag = "2")]
pub view: i32,
}
/// Request message for `Versions.CreateVersion`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVersionRequest {
/// Name of the parent resource to create this version under. Example:
/// `apps/myapp/services/default`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Application deployment configuration.
#[prost(message, optional, tag = "2")]
pub version: ::core::option::Option,
}
/// Request message for `Versions.UpdateVersion`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVersionRequest {
/// Name of the resource to update. Example:
/// `apps/myapp/services/default/versions/1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// A Version containing the updated resource. Only fields set in the field
/// mask will be updated.
#[prost(message, optional, tag = "2")]
pub version: ::core::option::Option,
/// Standard field mask for the set of fields to be updated.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for `Versions.DeleteVersion`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteVersionRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/services/default/versions/v1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Instances.ListInstances`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInstancesRequest {
/// Name of the parent Version resource. Example:
/// `apps/myapp/services/default/versions/v1`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `Instances.ListInstances`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInstancesResponse {
/// The instances belonging to the requested version.
#[prost(message, repeated, tag = "1")]
pub instances: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `Instances.GetInstance`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInstanceRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/services/default/versions/v1/instances/instance-1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Instances.DeleteInstance`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInstanceRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/services/default/versions/v1/instances/instance-1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Instances.DebugInstance`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebugInstanceRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/services/default/versions/v1/instances/instance-1`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Public SSH key to add to the instance. Examples:
///
/// * `\[USERNAME\]:ssh-rsa \[KEY_VALUE\] \[USERNAME\]`
/// * `\[USERNAME\]:ssh-rsa \[KEY_VALUE\] google-ssh {"userName":"\[USERNAME]","expireOn":"[EXPIRE_TIME\]"}`
///
/// For more information, see
/// [Adding and Removing SSH Keys]().
#[prost(string, tag = "2")]
pub ssh_key: ::prost::alloc::string::String,
}
/// Request message for `Firewall.ListIngressRules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListIngressRulesRequest {
/// Name of the Firewall collection to retrieve.
/// Example: `apps/myapp/firewall/ingressRules`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
/// A valid IP Address. If set, only rules matching this address will be
/// returned. The first returned rule will be the rule that fires on requests
/// from this IP.
#[prost(string, tag = "4")]
pub matching_address: ::prost::alloc::string::String,
}
/// Response message for `Firewall.ListIngressRules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListIngressRulesResponse {
/// The ingress FirewallRules for this application.
#[prost(message, repeated, tag = "1")]
pub ingress_rules: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `Firewall.BatchUpdateIngressRules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdateIngressRulesRequest {
/// Name of the Firewall collection to set.
/// Example: `apps/myapp/firewall/ingressRules`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// A list of FirewallRules to replace the existing set.
#[prost(message, repeated, tag = "2")]
pub ingress_rules: ::prost::alloc::vec::Vec,
}
/// Response message for `Firewall.UpdateAllIngressRules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdateIngressRulesResponse {
/// The full list of ingress FirewallRules for this application.
#[prost(message, repeated, tag = "1")]
pub ingress_rules: ::prost::alloc::vec::Vec,
}
/// Request message for `Firewall.CreateIngressRule`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIngressRuleRequest {
/// Name of the parent Firewall collection in which to create a new rule.
/// Example: `apps/myapp/firewall/ingressRules`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// A FirewallRule containing the new resource.
///
/// The user may optionally provide a position at which the new rule will be
/// placed. The positions define a sequential list starting at 1. If a rule
/// already exists at the given position, rules greater than the provided
/// position will be moved forward by one.
///
/// If no position is provided, the server will place the rule as the second to
/// last rule in the sequence before the required default allow-all or deny-all
/// rule.
#[prost(message, optional, tag = "2")]
pub rule: ::core::option::Option,
}
/// Request message for `Firewall.GetIngressRule`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIngressRuleRequest {
/// Name of the Firewall resource to retrieve.
/// Example: `apps/myapp/firewall/ingressRules/100`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `Firewall.UpdateIngressRule`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIngressRuleRequest {
/// Name of the Firewall resource to update.
/// Example: `apps/myapp/firewall/ingressRules/100`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// A FirewallRule containing the updated resource
#[prost(message, optional, tag = "2")]
pub rule: ::core::option::Option,
/// Standard field mask for the set of fields to be updated.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for `Firewall.DeleteIngressRule`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteIngressRuleRequest {
/// Name of the Firewall resource to delete.
/// Example: `apps/myapp/firewall/ingressRules/100`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `AuthorizedDomains.ListAuthorizedDomains`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAuthorizedDomainsRequest {
/// Name of the parent Application resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `AuthorizedDomains.ListAuthorizedDomains`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAuthorizedDomainsResponse {
/// The authorized domains belonging to the user.
#[prost(message, repeated, tag = "1")]
pub domains: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `AuthorizedCertificates.ListAuthorizedCertificates`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAuthorizedCertificatesRequest {
/// Name of the parent `Application` resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Controls the set of fields returned in the `LIST` response.
#[prost(enumeration = "AuthorizedCertificateView", tag = "4")]
pub view: i32,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `AuthorizedCertificates.ListAuthorizedCertificates`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAuthorizedCertificatesResponse {
/// The SSL certificates the user is authorized to administer.
#[prost(message, repeated, tag = "1")]
pub certificates: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `AuthorizedCertificates.GetAuthorizedCertificate`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAuthorizedCertificateRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/authorizedCertificates/12345`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Controls the set of fields returned in the `GET` response.
#[prost(enumeration = "AuthorizedCertificateView", tag = "2")]
pub view: i32,
}
/// Request message for `AuthorizedCertificates.CreateAuthorizedCertificate`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAuthorizedCertificateRequest {
/// Name of the parent `Application` resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// SSL certificate data.
#[prost(message, optional, tag = "2")]
pub certificate: ::core::option::Option,
}
/// Request message for `AuthorizedCertificates.UpdateAuthorizedCertificate`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAuthorizedCertificateRequest {
/// Name of the resource to update. Example:
/// `apps/myapp/authorizedCertificates/12345`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// An `AuthorizedCertificate` containing the updated resource. Only fields set
/// in the field mask will be updated.
#[prost(message, optional, tag = "2")]
pub certificate: ::core::option::Option,
/// Standard field mask for the set of fields to be updated. Updates are only
/// supported on the `certificate_raw_data` and `display_name` fields.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for `AuthorizedCertificates.DeleteAuthorizedCertificate`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteAuthorizedCertificateRequest {
/// Name of the resource to delete. Example:
/// `apps/myapp/authorizedCertificates/12345`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `DomainMappings.ListDomainMappings`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDomainMappingsRequest {
/// Name of the parent Application resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Maximum results to return per page.
#[prost(int32, tag = "2")]
pub page_size: i32,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
}
/// Response message for `DomainMappings.ListDomainMappings`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDomainMappingsResponse {
/// The domain mappings for the application.
#[prost(message, repeated, tag = "1")]
pub domain_mappings: ::prost::alloc::vec::Vec,
/// Continuation token for fetching the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for `DomainMappings.GetDomainMapping`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDomainMappingRequest {
/// Name of the resource requested. Example:
/// `apps/myapp/domainMappings/example.com`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request message for `DomainMappings.CreateDomainMapping`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDomainMappingRequest {
/// Name of the parent Application resource. Example: `apps/myapp`.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Domain mapping configuration.
#[prost(message, optional, tag = "2")]
pub domain_mapping: ::core::option::Option,
/// Whether the domain creation should override any existing mappings for this
/// domain. By default, overrides are rejected.
#[prost(enumeration = "DomainOverrideStrategy", tag = "4")]
pub override_strategy: i32,
}
/// Request message for `DomainMappings.UpdateDomainMapping`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDomainMappingRequest {
/// Name of the resource to update. Example:
/// `apps/myapp/domainMappings/example.com`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// A domain mapping containing the updated resource. Only fields set
/// in the field mask will be updated.
#[prost(message, optional, tag = "2")]
pub domain_mapping: ::core::option::Option,
/// Standard field mask for the set of fields to be updated.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for `DomainMappings.DeleteDomainMapping`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDomainMappingRequest {
/// Name of the resource to delete. Example:
/// `apps/myapp/domainMappings/example.com`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Fields that should be returned when \[Version][google.appengine.v1beta.Version\] resources
/// are retrieved.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum VersionView {
/// Basic version information including scaling and inbound services,
/// but not detailed deployment information.
Basic = 0,
/// The information from `BASIC`, plus detailed information about the
/// deployment. This format is required when creating resources, but
/// is not returned in `Get` or `List` by default.
Full = 1,
}
/// Fields that should be returned when an AuthorizedCertificate resource is
/// retrieved.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AuthorizedCertificateView {
/// Basic certificate information, including applicable domains and expiration
/// date.
BasicCertificate = 0,
/// The information from `BASIC_CERTIFICATE`, plus detailed information on the
/// domain mappings that have this certificate mapped.
FullCertificate = 1,
}
/// Override strategy for mutating an existing mapping.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DomainOverrideStrategy {
/// Strategy unspecified. Defaults to `STRICT`.
UnspecifiedDomainOverrideStrategy = 0,
/// Overrides not allowed. If a mapping already exists for the
/// specified domain, the request will return an ALREADY_EXISTS (409).
Strict = 1,
/// Overrides allowed. If a mapping already exists for the specified domain,
/// the request will overwrite it. Note that this might stop another
/// Google product from serving. For example, if the domain is
/// mapped to another App Engine application, that app will no
/// longer serve from that domain.
Override = 2,
}
#[doc = r" Generated client implementations."]
pub mod applications_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages App Engine applications."]
#[derive(Debug, Clone)]
pub struct ApplicationsClient {
inner: tonic::client::Grpc,
}
impl ApplicationsClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> ApplicationsClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
ApplicationsClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Gets information about an application."]
pub async fn get_application(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Applications/GetApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Creates an App Engine application for a Google Cloud Platform project."]
#[doc = " Required fields:"]
#[doc = ""]
#[doc = " * `id` - The ID of the target Cloud Platform project."]
#[doc = " * *location* - The [region](https://cloud.google.com/appengine/docs/locations) where you want the App Engine application located."]
#[doc = ""]
#[doc = " For more information about App Engine applications, see [Managing Projects, Applications, and Billing](https://cloud.google.com/appengine/docs/standard/python/console/)."]
pub async fn create_application(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Applications/CreateApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified Application resource."]
#[doc = " You can update the following fields:"]
#[doc = ""]
#[doc = " * `auth_domain` - Google authentication domain for controlling user access to the application."]
#[doc = " * `default_cookie_expiration` - Cookie expiration policy for the application."]
pub async fn update_application(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Applications/UpdateApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Recreates the required App Engine features for the specified App Engine"]
#[doc = " application, for example a Cloud Storage bucket or App Engine service"]
#[doc = " account."]
#[doc = " Use this method if you receive an error message about a missing feature,"]
#[doc = " for example, *Error retrieving the App Engine service account*."]
#[doc = " If you have deleted your App Engine service account, this will"]
#[doc = " not be able to recreate it. Instead, you should attempt to use the"]
#[doc = " IAM undelete API if possible at https://cloud.google.com/iam/reference/rest/v1/projects.serviceAccounts/undelete?apix_params=%7B\"name\"%3A\"projects%2F-%2FserviceAccounts%2Funique_id\"%2C\"resource\"%3A%7B%7D%7D ."]
#[doc = " If the deletion was recent, the numeric ID can be found in the Cloud"]
#[doc = " Console Activity Log."]
pub async fn repair_application(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Applications/RepairApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod services_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages services of an application."]
#[derive(Debug, Clone)]
pub struct ServicesClient {
inner: tonic::client::Grpc,
}
impl ServicesClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> ServicesClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
ServicesClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists all the services in the application."]
pub async fn list_services(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Services/ListServices",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the current configuration of the specified service."]
pub async fn get_service(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Services/GetService",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the configuration of the specified service."]
pub async fn update_service(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Services/UpdateService",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes the specified service and all enclosed versions."]
pub async fn delete_service(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Services/DeleteService",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod versions_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages versions of a service."]
#[derive(Debug, Clone)]
pub struct VersionsClient {
inner: tonic::client::Grpc,
}
impl VersionsClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> VersionsClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
VersionsClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists the versions of a service."]
pub async fn list_versions(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Versions/ListVersions",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the specified Version resource."]
#[doc = " By default, only a `BASIC_VIEW` will be returned."]
#[doc = " Specify the `FULL_VIEW` parameter to get the full resource."]
pub async fn get_version(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Versions/GetVersion",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deploys code and resource files to a new version."]
pub async fn create_version(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Versions/CreateVersion",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified Version resource."]
#[doc = " You can specify the following fields depending on the App Engine"]
#[doc = " environment and type of scaling that the version resource uses:"]
#[doc = ""]
#[doc = " **Standard environment**"]
#[doc = ""]
#[doc = " * [`instance_class`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.instance_class)"]
#[doc = ""]
#[doc = " *automatic scaling* in the standard environment:"]
#[doc = ""]
#[doc = " * [`automatic_scaling.min_idle_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = " * [`automatic_scaling.max_idle_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = " * [`automaticScaling.standard_scheduler_settings.max_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#StandardSchedulerSettings)"]
#[doc = " * [`automaticScaling.standard_scheduler_settings.min_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#StandardSchedulerSettings)"]
#[doc = " * [`automaticScaling.standard_scheduler_settings.target_cpu_utilization`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#StandardSchedulerSettings)"]
#[doc = " * [`automaticScaling.standard_scheduler_settings.target_throughput_utilization`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#StandardSchedulerSettings)"]
#[doc = ""]
#[doc = " *basic scaling* or *manual scaling* in the standard environment:"]
#[doc = ""]
#[doc = " * [`serving_status`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.serving_status)"]
#[doc = " * [`manual_scaling.instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#manualscaling)"]
#[doc = ""]
#[doc = " **Flexible environment**"]
#[doc = ""]
#[doc = " * [`serving_status`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.serving_status)"]
#[doc = ""]
#[doc = " *automatic scaling* in the flexible environment:"]
#[doc = ""]
#[doc = " * [`automatic_scaling.min_total_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = " * [`automatic_scaling.max_total_instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = " * [`automatic_scaling.cool_down_period_sec`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = " * [`automatic_scaling.cpu_utilization.target_utilization`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#Version.FIELDS.automatic_scaling)"]
#[doc = ""]
#[doc = " *manual scaling* in the flexible environment:"]
#[doc = ""]
#[doc = " * [`manual_scaling.instances`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1beta/apps.services.versions#manualscaling)"]
pub async fn update_version(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Versions/UpdateVersion",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes an existing Version resource."]
pub async fn delete_version(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Versions/DeleteVersion",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod instances_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages instances of a version."]
#[derive(Debug, Clone)]
pub struct InstancesClient {
inner: tonic::client::Grpc,
}
impl InstancesClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> InstancesClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
InstancesClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists the instances of a version."]
#[doc = ""]
#[doc = " Tip: To aggregate details about instances over time, see the"]
#[doc = " [Stackdriver Monitoring API](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list)."]
pub async fn list_instances(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Instances/ListInstances",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets instance information."]
pub async fn get_instance(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Instances/GetInstance",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Stops a running instance."]
#[doc = ""]
#[doc = " The instance might be automatically recreated based on the scaling settings"]
#[doc = " of the version. For more information, see \"How Instances are Managed\""]
#[doc = " ([standard environment](https://cloud.google.com/appengine/docs/standard/python/how-instances-are-managed) |"]
#[doc = " [flexible environment](https://cloud.google.com/appengine/docs/flexible/python/how-instances-are-managed))."]
#[doc = ""]
#[doc = " To ensure that instances are not re-created and avoid getting billed, you"]
#[doc = " can stop all instances within the target version by changing the serving"]
#[doc = " status of the version to `STOPPED` with the"]
#[doc = " [`apps.services.versions.patch`](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions/patch)"]
#[doc = " method."]
pub async fn delete_instance(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Instances/DeleteInstance",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Enables debugging on a VM instance. This allows you to use the SSH"]
#[doc = " command to connect to the virtual machine where the instance lives."]
#[doc = " While in \"debug mode\", the instance continues to serve live traffic."]
#[doc = " You should delete the instance when you are done debugging and then"]
#[doc = " allow the system to take over and determine if another instance"]
#[doc = " should be started."]
#[doc = ""]
#[doc = " Only applicable for instances in App Engine flexible environment."]
pub async fn debug_instance(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Instances/DebugInstance",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod firewall_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Firewall resources are used to define a collection of access control rules"]
#[doc = " for an Application. Each rule is defined with a position which specifies"]
#[doc = " the rule's order in the sequence of rules, an IP range to be matched against"]
#[doc = " requests, and an action to take upon matching requests."]
#[doc = ""]
#[doc = " Every request is evaluated against the Firewall rules in priority order."]
#[doc = " Processesing stops at the first rule which matches the request's IP address."]
#[doc = " A final rule always specifies an action that applies to all remaining"]
#[doc = " IP addresses. The default final rule for a newly-created application will be"]
#[doc = " set to \"allow\" if not otherwise specified by the user."]
#[derive(Debug, Clone)]
pub struct FirewallClient {
inner: tonic::client::Grpc,
}
impl FirewallClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> FirewallClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
FirewallClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists the firewall rules of an application."]
pub async fn list_ingress_rules(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/ListIngressRules",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Replaces the entire firewall ruleset in one bulk operation. This overrides"]
#[doc = " and replaces the rules of an existing firewall with the new rules."]
#[doc = ""]
#[doc = " If the final rule does not match traffic with the '*' wildcard IP range,"]
#[doc = " then an \"allow all\" rule is explicitly added to the end of the list."]
pub async fn batch_update_ingress_rules(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/BatchUpdateIngressRules",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Creates a firewall rule for the application."]
pub async fn create_ingress_rule(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/CreateIngressRule",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the specified firewall rule."]
pub async fn get_ingress_rule(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/GetIngressRule",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified firewall rule."]
pub async fn update_ingress_rule(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/UpdateIngressRule",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes the specified firewall rule."]
pub async fn delete_ingress_rule(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.Firewall/DeleteIngressRule",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod authorized_domains_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages domains a user is authorized to administer. To authorize use of a"]
#[doc = " domain, verify ownership via"]
#[doc = " [Webmaster Central](https://www.google.com/webmasters/verification/home)."]
#[derive(Debug, Clone)]
pub struct AuthorizedDomainsClient {
inner: tonic::client::Grpc,
}
impl AuthorizedDomainsClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> AuthorizedDomainsClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
AuthorizedDomainsClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists all domains the user is authorized to administer."]
pub async fn list_authorized_domains(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedDomains/ListAuthorizedDomains",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod authorized_certificates_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages SSL certificates a user is authorized to administer. A user can"]
#[doc = " administer any SSL certificates applicable to their authorized domains."]
#[derive(Debug, Clone)]
pub struct AuthorizedCertificatesClient {
inner: tonic::client::Grpc,
}
impl AuthorizedCertificatesClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> AuthorizedCertificatesClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
AuthorizedCertificatesClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists all SSL certificates the user is authorized to administer."]
pub async fn list_authorized_certificates(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedCertificates/ListAuthorizedCertificates",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the specified SSL certificate."]
pub async fn get_authorized_certificate(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedCertificates/GetAuthorizedCertificate",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Uploads the specified SSL certificate."]
pub async fn create_authorized_certificate(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedCertificates/CreateAuthorizedCertificate",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified SSL certificate. To renew a certificate and maintain"]
#[doc = " its existing domain mappings, update `certificate_data` with a new"]
#[doc = " certificate. The new certificate must be applicable to the same domains as"]
#[doc = " the original certificate. The certificate `display_name` may also be"]
#[doc = " updated."]
pub async fn update_authorized_certificate(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedCertificates/UpdateAuthorizedCertificate",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes the specified SSL certificate."]
pub async fn delete_authorized_certificate(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.AuthorizedCertificates/DeleteAuthorizedCertificate",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
#[doc = r" Generated client implementations."]
pub mod domain_mappings_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Manages domains serving an application."]
#[derive(Debug, Clone)]
pub struct DomainMappingsClient {
inner: tonic::client::Grpc,
}
impl DomainMappingsClient
where
T: tonic::client::GrpcService,
T::ResponseBody: Body + Send + 'static,
T::Error: Into,
::Error: Into + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor(
inner: T,
interceptor: F,
) -> DomainMappingsClient>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request,
Response = http::Response<
>::ResponseBody,
>,
>,
>>::Error:
Into + Send + Sync,
{
DomainMappingsClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists the domain mappings on an application."]
pub async fn list_domain_mappings(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.DomainMappings/ListDomainMappings",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the specified domain mapping."]
pub async fn get_domain_mapping(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.DomainMappings/GetDomainMapping",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Maps a domain to an application. A user must be authorized to administer a"]
#[doc = " domain in order to map it to an application. For a list of available"]
#[doc = " authorized domains, see [`AuthorizedDomains.ListAuthorizedDomains`]()."]
pub async fn create_domain_mapping(
&mut self,
request: impl tonic::IntoRequest,
) -> Result, 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.appengine.v1beta.DomainMappings/CreateDomainMapping",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified domain mapping. To map an SSL certificate to a"]
#[doc = " domain mapping, update `certificate_id` to point to an `AuthorizedCertificate`"]
#[doc = " resource. A user must be authorized to administer the associated domain"]
#[doc = " in order to update a `DomainMapping` resource."]
pub async fn update_domain_mapping(
&mut self,
request: impl tonic::IntoRequest,
) -> Result