#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct AbortRolloutRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreatePreviewRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preview: Option<Preview>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "previewId"
)]
pub preview_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateRolloutRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rollout: Option<Rollout>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "rolloutId"
)]
pub rollout_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateServiceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service: Option<Service>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "serviceId"
)]
pub service_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateSourceLinkRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none", alias = "sourceLink")]
pub source_link: Option<SourceLink>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "sourceLinkId"
)]
pub source_link_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeletePreviewRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteServiceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub force: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteSourceLinkRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetPreviewRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetRolloutRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetServiceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetSourceLinkRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListPreviewsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListPreviewsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub previews: Vec<Preview>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListServiceRolloutsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListServiceRolloutsResponse {
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "serviceRollouts"
)]
pub service_rollouts: Vec<Rollout>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListServicesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListServicesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub services: Vec<Service>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListSourceLinksRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListSourceLinksResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "sourceLinks")]
pub source_links: Vec<SourceLink>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct PauseRolloutRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Preview {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<PreviewSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<PreviewStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct PreviewSpec {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub service: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pullRequest"
)]
pub pull_request: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct PreviewStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<PreviewState>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uri: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub commit: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "expireTime"
)]
pub expire_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ResumeRolloutRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Rollout {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<RolloutSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<RolloutStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RolloutSpec {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub release: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "serviceGeneration"
)]
pub service_generation: i64,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RolloutStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<RolloutState>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub wave: Option<RolloutWave>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub cells: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "startTime"
)]
pub start_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "endTime"
)]
pub end_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Service {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<ServiceSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ServiceStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceBuild {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "rootDirectory"
)]
pub root_directory: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub dockerfile: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "buildClass"
)]
pub build_class: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceHealth {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub protocol: Option<HealthProtocol>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub path: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "startupTimeout"
)]
pub startup_timeout: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceScaling {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "minInstances"
)]
pub min_instances: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "maxInstances"
)]
pub max_instances: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceSource {
#[serde(default, skip_serializing_if = "Option::is_none", alias = "sourceLink")]
pub source_link: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub branch: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub build: Option<ServiceBuild>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceSpec {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<ServiceSource>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub command: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub port: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exposure: Option<ServiceExposure>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub size: Option<InstanceSize>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scaling: Option<ServiceScaling>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub health: Option<ServiceHealth>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub env: std::collections::BTreeMap<String, String>,
#[serde(
default,
skip_serializing_if = "std::collections::BTreeMap::is_empty",
alias = "secretEnv"
)]
pub secret_env: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub regions: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ServiceStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uri: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub release: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub image: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub rollout: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "readyInstances"
)]
pub ready_instances: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SourceLink {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<SourceLinkSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<SourceLinkStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SourceLinkSpec {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub connection: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub repository: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "productionBranch"
)]
pub production_branch: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "previewsEnabled"
)]
pub previews_enabled: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SourceLinkStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "defaultBranch"
)]
pub default_branch: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "headCommit"
)]
pub head_commit: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "lastDeliveryTime"
)]
pub last_delivery_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateServiceRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service: Option<Service>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateSourceLinkRequest {
#[serde(default, skip_serializing_if = "Option::is_none", alias = "sourceLink")]
pub source_link: Option<SourceLink>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum HealthProtocol {
Http,
Tcp,
Unknown(String),
}
impl HealthProtocol {
pub fn as_str(&self) -> &str {
match self {
Self::Http => "http",
Self::Tcp => "tcp",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"http" => Self::Http,
"tcp" => Self::Tcp,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for HealthProtocol {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for HealthProtocol {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for HealthProtocol {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum InstanceSize {
Nano,
Micro,
Small,
Standard,
Large,
Xlarge,
Xxlarge,
Unknown(String),
}
impl InstanceSize {
pub fn as_str(&self) -> &str {
match self {
Self::Nano => "nano",
Self::Micro => "micro",
Self::Small => "small",
Self::Standard => "standard",
Self::Large => "large",
Self::Xlarge => "xlarge",
Self::Xxlarge => "xxlarge",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"nano" => Self::Nano,
"micro" => Self::Micro,
"small" => Self::Small,
"standard" => Self::Standard,
"large" => Self::Large,
"xlarge" => Self::Xlarge,
"xxlarge" => Self::Xxlarge,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for InstanceSize {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for InstanceSize {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for InstanceSize {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PreviewState {
Building,
Serving,
Failed,
Closed,
Unknown(String),
}
impl PreviewState {
pub fn as_str(&self) -> &str {
match self {
Self::Building => "building",
Self::Serving => "serving",
Self::Failed => "failed",
Self::Closed => "closed",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"building" => Self::Building,
"serving" => Self::Serving,
"failed" => Self::Failed,
"closed" => Self::Closed,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for PreviewState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for PreviewState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for PreviewState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RolloutState {
Pending,
Progressing,
Paused,
Succeeded,
Aborted,
Failed,
Superseded,
Unknown(String),
}
impl RolloutState {
pub fn as_str(&self) -> &str {
match self {
Self::Pending => "pending",
Self::Progressing => "progressing",
Self::Paused => "paused",
Self::Succeeded => "succeeded",
Self::Aborted => "aborted",
Self::Failed => "failed",
Self::Superseded => "superseded",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"pending" => Self::Pending,
"progressing" => Self::Progressing,
"paused" => Self::Paused,
"succeeded" => Self::Succeeded,
"aborted" => Self::Aborted,
"failed" => Self::Failed,
"superseded" => Self::Superseded,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for RolloutState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for RolloutState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for RolloutState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RolloutWave {
Canary,
Cell,
Region,
All,
Unknown(String),
}
impl RolloutWave {
pub fn as_str(&self) -> &str {
match self {
Self::Canary => "canary",
Self::Cell => "cell",
Self::Region => "region",
Self::All => "all",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"canary" => Self::Canary,
"cell" => Self::Cell,
"region" => Self::Region,
"all" => Self::All,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for RolloutWave {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for RolloutWave {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for RolloutWave {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ServiceExposure {
Public,
Internal,
Unknown(String),
}
impl ServiceExposure {
pub fn as_str(&self) -> &str {
match self {
Self::Public => "public",
Self::Internal => "internal",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"public" => Self::Public,
"internal" => Self::Internal,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ServiceExposure {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for ServiceExposure {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for ServiceExposure {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn hosting(&self) -> HostingApi<'_, T> {
HostingApi { client: self }
}
}
pub struct HostingApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> HostingApi<'a, T> {
pub fn services(&self) -> ServicesCollection<'a, T> {
ServicesCollection {
client: self.client,
}
}
pub fn service_rollouts(&self) -> ServiceRolloutsCollection<'a, T> {
ServiceRolloutsCollection {
client: self.client,
}
}
pub fn previews(&self) -> PreviewsCollection<'a, T> {
PreviewsCollection {
client: self.client,
}
}
pub fn source_links(&self) -> SourceLinksCollection<'a, T> {
SourceLinksCollection {
client: self.client,
}
}
}
pub struct ServicesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ServicesCollection<'a, T> {
pub async fn get(&self, request: GetServiceRequest) -> Result<Service, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListServicesRequest,
) -> Result<ListServicesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/services",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListServicesRequest,
) -> Result<Vec<Service>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.services);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateServiceRequest,
) -> Result<crate::runtime::Operation<'a, T, Service>, crate::runtime::Error> {
let path = format!(
"/v1/{}/services",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("service_id", &request.service_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.service)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn update(
&self,
request: UpdateServiceRequest,
) -> Result<crate::runtime::Operation<'a, T, Service>, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.service
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/services/*",
"service.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.service)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeleteServiceRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
query.push("force", &request.force);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
}
pub struct ServiceRolloutsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ServiceRolloutsCollection<'a, T> {
pub async fn get(&self, request: GetRolloutRequest) -> Result<Rollout, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*/service_rollouts/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListServiceRolloutsRequest,
) -> Result<ListServiceRolloutsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/service_rollouts",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/services/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListServiceRolloutsRequest,
) -> Result<Vec<Rollout>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.service_rollouts);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateRolloutRequest,
) -> Result<Rollout, crate::runtime::Error> {
let path = format!(
"/v1/{}/service_rollouts",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/services/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("rollout_id", &request.rollout_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.rollout)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn pause(
&self,
request: PauseRolloutRequest,
) -> Result<Rollout, crate::runtime::Error> {
let path = format!(
"/v1/{}:pause",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*/service_rollouts/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn resume(
&self,
request: ResumeRolloutRequest,
) -> Result<Rollout, crate::runtime::Error> {
let path = format!(
"/v1/{}:resume",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*/service_rollouts/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn abort(
&self,
request: AbortRolloutRequest,
) -> Result<Rollout, crate::runtime::Error> {
let path = format!(
"/v1/{}:abort",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/services/*/service_rollouts/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct PreviewsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> PreviewsCollection<'a, T> {
pub async fn get(&self, request: GetPreviewRequest) -> Result<Preview, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/previews/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListPreviewsRequest,
) -> Result<ListPreviewsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/previews",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListPreviewsRequest,
) -> Result<Vec<Preview>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.previews);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreatePreviewRequest,
) -> Result<crate::runtime::Operation<'a, T, Preview>, crate::runtime::Error> {
let path = format!(
"/v1/{}/previews",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("preview_id", &request.preview_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.preview)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeletePreviewRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/previews/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
}
pub struct SourceLinksCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> SourceLinksCollection<'a, T> {
pub async fn get(
&self,
request: GetSourceLinkRequest,
) -> Result<SourceLink, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/source_links/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListSourceLinksRequest,
) -> Result<ListSourceLinksResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/source_links",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListSourceLinksRequest,
) -> Result<Vec<SourceLink>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.source_links);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateSourceLinkRequest,
) -> Result<crate::runtime::Operation<'a, T, SourceLink>, crate::runtime::Error> {
let path = format!(
"/v1/{}/source_links",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("source_link_id", &request.source_link_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.source_link)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn update(
&self,
request: UpdateSourceLinkRequest,
) -> Result<crate::runtime::Operation<'a, T, SourceLink>, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.source_link
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/source_links/*",
"source_link.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.source_link)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeleteSourceLinkRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/source_links/*", "name")?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
}