/// The message used by the client to register interest in an entity. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Request { /// The `target` value **must** be a valid URL path pointing to an entity /// to watch. Note that the service name **must** be /// removed from the target field (e.g., the target field must say /// "/foo/bar", not "myservice.googleapis.com/foo/bar"). A client is /// also allowed to pass system-specific parameters in the URL that /// are only obeyed by some implementations. Some parameters will be /// implementation-specific. However, some have predefined meaning /// and are listed here: /// /// * recursive = true|false \[default=false\] /// If set to true, indicates that the client wants to watch all elements /// of entities in the subtree rooted at the entity's name in `target`. For /// descendants that are not the immediate children of the target, the /// `Change.element` will contain slashes. /// /// Note that some namespaces and entities will not support recursive /// watching. When watching such an entity, a client must not set recursive /// to true. Otherwise, it will receive an `UNIMPLEMENTED` error. /// /// Normal URL encoding must be used inside `target`. For example, if a query /// parameter name or value, or the non-query parameter portion of `target` /// contains a special character, it must be %-encoded. We recommend that /// clients and servers use their runtime's URL library to produce and consume /// target values. #[prost(string, tag = "1")] pub target: ::prost::alloc::string::String, /// The `resume_marker` specifies how much of the existing underlying state is /// delivered to the client when the watch request is received by the /// system. The client can set this marker in one of the following ways to get /// different semantics: /// /// * Parameter is not specified or has the value "". /// Semantics: Fetch initial state. /// The client wants the entity's initial state to be delivered. See the /// description in "Initial State". /// /// * Parameter is set to the string "now" (UTF-8 encoding). /// Semantics: Fetch new changes only. /// The client just wants to get the changes received by the system after /// the watch point. The system may deliver changes from before the watch /// point as well. /// /// * Parameter is set to a value received in an earlier /// `Change.resume_marker` field while watching the same entity. /// Semantics: Resume from a specific point. /// The client wants to receive the changes from a specific point; this /// value must correspond to a value received in the `Change.resume_marker` /// field. The system may deliver changes from before the `resume_marker` /// as well. If the system cannot resume the stream from this point (e.g., /// if it is too far behind in the stream), it can raise the /// `FAILED_PRECONDITION` error. /// /// An implementation MUST support an unspecified parameter and the /// empty string "" marker (initial state fetching) and the "now" marker. /// It need not support resuming from a specific point. #[prost(bytes = "vec", tag = "2")] pub resume_marker: ::prost::alloc::vec::Vec, } /// A batch of Change messages. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ChangeBatch { /// A list of Change messages. #[prost(message, repeated, tag = "1")] pub changes: ::prost::alloc::vec::Vec, } /// A Change indicates the most recent state of an element. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Change { /// Name of the element, interpreted relative to the entity's actual /// name. "" refers to the entity itself. The element name is a valid /// UTF-8 string. #[prost(string, tag = "1")] pub element: ::prost::alloc::string::String, /// The state of the `element`. #[prost(enumeration = "change::State", tag = "2")] pub state: i32, /// The actual change data. This field is present only when `state() == EXISTS` /// or `state() == ERROR`. Please see /// \[google.protobuf.Any][google.protobuf.Any\] about how to use the Any type. #[prost(message, optional, tag = "6")] pub data: ::core::option::Option<::prost_types::Any>, /// If present, provides a compact representation of all the messages that have /// been received by the caller for the given entity, e.g., it could be a /// sequence number or a multi-part timestamp/version vector. This marker can /// be provided in the Request message, allowing the caller to resume the /// stream watching at a specific point without fetching the initial state. #[prost(bytes = "vec", tag = "4")] pub resume_marker: ::prost::alloc::vec::Vec, /// If true, this Change is followed by more Changes that are in the same group /// as this Change. #[prost(bool, tag = "5")] pub continued: bool, } /// Nested message and enum types in `Change`. pub mod change { /// A reported value can be in one of the following states: #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The element exists and its full value is included in data. Exists = 0, /// The element does not exist. DoesNotExist = 1, /// Element may or may not exist. Used only for initial state delivery when /// the client is not interested in fetching the initial state. See the /// "Initial State" section above. InitialStateSkipped = 2, /// The element may exist, but some error has occurred. More information is /// available in the data field - the value is a serialized Status /// proto (from \[google.rpc.Status][\]) Error = 3, } } #[doc = r" Generated client implementations."] pub mod watcher_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " The service that a client uses to connect to the watcher system."] #[doc = " The errors returned by the service are in the canonical error space,"] #[doc = " see [google.rpc.Code][]."] #[derive(Debug, Clone)] pub struct WatcherClient { inner: tonic::client::Grpc, } impl WatcherClient 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, ) -> WatcherClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { WatcherClient::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 = " Start a streaming RPC to get watch information from the server."] pub async fn watch( &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.watcher.v1.Watcher/Watch"); self.inner.server_streaming(request.into_request(), path, codec).await } } }