#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateReleaseRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub release: Option<Release>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub release_id: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetReleaseRequest {
#[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 ListReleasesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub page_size: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
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")]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListReleasesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub releases: Vec<Release>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListRolloutsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub page_size: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
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")]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListRolloutsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub rollouts: Vec<Rollout>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Placement {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub regions: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub cells: Vec<String>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub attributes: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub replicas: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Release {
#[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<ReleaseSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ReleaseStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ReleaseMember {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub workload: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub artifact: String,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub config: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub secrets: Vec<SecretPin>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub placement: Option<Placement>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ReleaseMemberStatus {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub workload: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub observed_digest: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub converged_cell_count: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub cell_count: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ReleaseSpec {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub members: Vec<ReleaseMember>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rollout_policy: Option<RolloutPolicy>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ReleaseStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64"
)]
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<ReleaseState>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub rollout: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub previous_release: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub successor: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub member_statuses: Vec<ReleaseMemberStatus>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub live_time: String,
}
#[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 = "crate::runtime::is_default")]
pub release: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<RolloutState>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub waves: Vec<Wave>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub current_wave: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub start_time: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub end_time: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub halt_reason: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RolloutPolicy {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub bake_duration: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub halt_on_failure: Option<bool>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub skip_waves: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SecretPin {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub binding: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Wave {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<WaveScope>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub cells: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<RolloutState>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub healthy_cell_count: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub start_time: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub end_time: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ReleaseState {
Pending,
RollingOut,
Live,
Failed,
Superseded,
Rejected,
Unknown(String),
}
impl ReleaseState {
pub fn as_str(&self) -> &str {
match self {
Self::Pending => "pending",
Self::RollingOut => "rolling_out",
Self::Live => "live",
Self::Failed => "failed",
Self::Superseded => "superseded",
Self::Rejected => "rejected",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"pending" => Self::Pending,
"rolling_out" => Self::RollingOut,
"live" => Self::Live,
"failed" => Self::Failed,
"superseded" => Self::Superseded,
"rejected" => Self::Rejected,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ReleaseState {
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 ReleaseState {
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 ReleaseState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RolloutState {
Waiting,
InProgress,
Succeeded,
Failed,
Superseded,
Unknown(String),
}
impl RolloutState {
pub fn as_str(&self) -> &str {
match self {
Self::Waiting => "waiting",
Self::InProgress => "in_progress",
Self::Succeeded => "succeeded",
Self::Failed => "failed",
Self::Superseded => "superseded",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"waiting" => Self::Waiting,
"in_progress" => Self::InProgress,
"succeeded" => Self::Succeeded,
"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 WaveScope {
Canary,
Cell,
Region,
All,
Unknown(String),
}
impl WaveScope {
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 WaveScope {
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 WaveScope {
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 WaveScope {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn release(&self) -> ReleaseApi<'_, T> {
ReleaseApi { client: self }
}
}
pub struct ReleaseApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ReleaseApi<'a, T> {
pub fn releases(&self) -> ReleasesCollection<'a, T> {
ReleasesCollection {
client: self.client,
}
}
pub fn rollouts(&self) -> RolloutsCollection<'a, T> {
RolloutsCollection {
client: self.client,
}
}
}
pub struct ReleasesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ReleasesCollection<'a, T> {
pub async fn get(&self, request: GetReleaseRequest) -> Result<Release, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/releases/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListReleasesRequest,
) -> Result<ListReleasesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/releases",
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,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListReleasesRequest,
) -> Result<Vec<Release>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.releases);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateReleaseRequest,
) -> Result<crate::runtime::Operation<'a, T, Release>, crate::runtime::Error> {
let path = format!(
"/v1/{}/releases",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("release_id", &request.release_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.release)?),
mutation: true,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
}
pub struct RolloutsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> RolloutsCollection<'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/*/rollouts/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListRolloutsRequest,
) -> Result<ListRolloutsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/rollouts",
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,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListRolloutsRequest,
) -> Result<Vec<Rollout>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.rollouts);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
}