origincloud-core 0.7.0

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/longrunning/v1beta1/operations.proto

/// The request for GetOperation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetOperationRequest {
    /// The operation to return, `projects/{project}/zones/{zone}/operations/{operation}`,
    /// exactly as a method returned it.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for WaitOperation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WaitOperationRequest {
    /// The operation to wait for, exactly as a method returned it.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The longest to wait, at most a minute; a minute when not set.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<crate::protobuf::Duration>,
}
/// What an operation is about.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationMetadata {
    /// The resource the operation acts on.
    #[prost(string, tag = "1")]
    pub target: ::prost::alloc::string::String,
    /// What it does, as the method that started it names it: for example
    /// `create`, `update` or `delete`.
    #[prost(string, tag = "2")]
    pub verb: ::prost::alloc::string::String,
    /// When it was accepted.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<crate::protobuf::Timestamp>,
    /// When it finished; empty while it hasn't.
    #[prost(message, optional, tag = "4")]
    pub end_time: ::core::option::Option<crate::protobuf::Timestamp>,
}
impl serde::Serialize for GetOperationRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.longrunning.v1beta1.GetOperationRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetOperationRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetOperationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.longrunning.v1beta1.GetOperationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetOperationRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetOperationRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.longrunning.v1beta1.GetOperationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for OperationMetadata {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.target.is_empty() {
            len += 1;
        }
        if !self.verb.is_empty() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.longrunning.v1beta1.OperationMetadata", len)?;
        if !self.target.is_empty() {
            struct_ser.serialize_field("target", &self.target)?;
        }
        if !self.verb.is_empty() {
            struct_ser.serialize_field("verb", &self.verb)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for OperationMetadata {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "target",
            "verb",
            "create_time",
            "createTime",
            "end_time",
            "endTime",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Target,
            Verb,
            CreateTime,
            EndTime,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "target" => Ok(GeneratedField::Target),
                            "verb" => Ok(GeneratedField::Verb),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = OperationMetadata;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.longrunning.v1beta1.OperationMetadata",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<OperationMetadata, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut target__ = None;
                let mut verb__ = None;
                let mut create_time__ = None;
                let mut end_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Target => {
                            if target__.is_some() {
                                return Err(serde::de::Error::duplicate_field("target"));
                            }
                            target__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Verb => {
                            if verb__.is_some() {
                                return Err(serde::de::Error::duplicate_field("verb"));
                            }
                            verb__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CreateTime => {
                            if create_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createTime"));
                            }
                            create_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(OperationMetadata {
                    target: target__.unwrap_or_default(),
                    verb: verb__.unwrap_or_default(),
                    create_time: create_time__,
                    end_time: end_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.longrunning.v1beta1.OperationMetadata",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for WaitOperationRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if self.timeout.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.longrunning.v1beta1.WaitOperationRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if let Some(v) = self.timeout.as_ref() {
            struct_ser.serialize_field("timeout", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for WaitOperationRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "timeout"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Timeout,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "timeout" => Ok(GeneratedField::Timeout),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = WaitOperationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.longrunning.v1beta1.WaitOperationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<WaitOperationRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut timeout__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Timeout => {
                            if timeout__.is_some() {
                                return Err(serde::de::Error::duplicate_field("timeout"));
                            }
                            timeout__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(WaitOperationRequest {
                    name: name__.unwrap_or_default(),
                    timeout: timeout__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.longrunning.v1beta1.WaitOperationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
/// Calls `OperationService`.
///
/// The long-running operations of a service: what its creates, updates and
/// deletes answer with, until their resource settles. Every service serves
/// this at its own host, for the operations its own methods return.
///
/// An operation is done when its resource reaches the state its method
/// promises, or failed when it can't get there; that outcome never changes
/// afterwards, whatever later happens to the resource. It can be read for a
/// day after it is done.
#[derive(Clone, Debug)]
pub struct OperationClient {
    service: crate::Service,
}
impl OperationClient {
    /// Returns a client of `OperationService` at `service`, the endpoint of another service's client: every service serves it at its own host.
    pub fn new(service: &crate::Service) -> Self {
        Self { service: service.clone() }
    }
    /// Returns an operation as it is now.
    pub async fn get_operation(
        &self,
        request: GetOperationRequest,
    ) -> ::core::result::Result<crate::longrunning::Operation, crate::Error> {
        let p0 = crate::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/operations/*",
        )?;
        let query = crate::query(&request, &["name"])?;
        let call = crate::Request::new(crate::Method::GET, format!("/v1beta1/{p0}"))
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Waits until an operation is done or `timeout` has passed, whichever
    /// comes first, and returns it as it is then. It only reads, so a client
    /// may repeat it after a transport error.
    pub async fn wait_operation(
        &self,
        request: WaitOperationRequest,
    ) -> ::core::result::Result<crate::longrunning::Operation, crate::Error> {
        let p0 = crate::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/operations/*",
        )?;
        let body = crate::json_body(&request)?;
        let call = crate::Request::new(
                crate::Method::POST,
                format!("/v1beta1/{p0}:wait"),
            )
            .with_body(body)
            .idempotent();
        self.service.call(call).await
    }
}