cx_api/generated/
com.coralogix.archive.v2.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct IbmCosTargetSpec {
6    #[prost(string, tag = "1")]
7    pub bucket_crn: ::prost::alloc::string::String,
8    #[prost(string, tag = "2")]
9    pub endpoint: ::prost::alloc::string::String,
10    #[prost(string, optional, tag = "3")]
11    pub service_crn: ::core::option::Option<::prost::alloc::string::String>,
12    #[prost(enumeration = "IbmBucketType", optional, tag = "4")]
13    pub bucket_type: ::core::option::Option<i32>,
14}
15#[derive(serde::Serialize, serde::Deserialize)]
16#[serde(rename_all = "snake_case")]
17#[derive(Clone, PartialEq, ::prost::Message)]
18pub struct S3TargetSpec {
19    #[prost(string, tag = "1")]
20    pub bucket: ::prost::alloc::string::String,
21    #[prost(string, optional, tag = "2")]
22    pub region: ::core::option::Option<::prost::alloc::string::String>,
23}
24#[derive(serde::Serialize, serde::Deserialize)]
25#[serde(rename_all = "snake_case")]
26#[derive(Clone, PartialEq, ::prost::Message)]
27pub struct ArchiveSpec {
28    #[prost(string, tag = "1")]
29    pub archiving_format_id: ::prost::alloc::string::String,
30    #[prost(bool, tag = "2")]
31    pub is_active: bool,
32    #[prost(bool, tag = "3")]
33    pub enable_tags: bool,
34}
35#[derive(serde::Serialize, serde::Deserialize)]
36#[serde(rename_all = "snake_case")]
37#[derive(Clone, PartialEq, ::prost::Message)]
38pub struct Target {
39    #[prost(message, optional, tag = "3")]
40    pub archive_spec: ::core::option::Option<ArchiveSpec>,
41    #[prost(oneof = "target::TargetSpec", tags = "1, 2")]
42    pub target_spec: ::core::option::Option<target::TargetSpec>,
43}
44/// Nested message and enum types in `Target`.
45pub mod target {
46    #[derive(serde::Serialize, serde::Deserialize)]
47    #[serde(rename_all = "snake_case")]
48    #[derive(Clone, PartialEq, ::prost::Oneof)]
49    pub enum TargetSpec {
50        #[prost(message, tag = "1")]
51        S3(super::S3TargetSpec),
52        #[prost(message, tag = "2")]
53        IbmCos(super::IbmCosTargetSpec),
54    }
55}
56#[derive(serde::Serialize, serde::Deserialize)]
57#[serde(rename_all = "snake_case")]
58#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
59#[repr(i32)]
60pub enum IbmBucketType {
61    Unspecified = 0,
62    External = 1,
63    Internal = 2,
64}
65impl IbmBucketType {
66    /// String value of the enum field names used in the ProtoBuf definition.
67    ///
68    /// The values are not transformed in any way and thus are considered stable
69    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
70    pub fn as_str_name(&self) -> &'static str {
71        match self {
72            Self::Unspecified => "IBM_BUCKET_TYPE_UNSPECIFIED",
73            Self::External => "IBM_BUCKET_TYPE_EXTERNAL",
74            Self::Internal => "IBM_BUCKET_TYPE_INTERNAL",
75        }
76    }
77    /// Creates an enum from field names used in the ProtoBuf definition.
78    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
79        match value {
80            "IBM_BUCKET_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
81            "IBM_BUCKET_TYPE_EXTERNAL" => Some(Self::External),
82            "IBM_BUCKET_TYPE_INTERNAL" => Some(Self::Internal),
83            _ => None,
84        }
85    }
86}
87#[derive(serde::Serialize, serde::Deserialize)]
88#[serde(rename_all = "snake_case")]
89#[derive(Clone, PartialEq, ::prost::Message)]
90pub struct InternalTargetServiceGetTargetsRequest {
91    #[prost(message, optional, tag = "1")]
92    pub filter: ::core::option::Option<InternalGetTargetsRequestFilter>,
93    #[prost(message, optional, tag = "2")]
94    pub order: ::core::option::Option<TargetResponseOrder>,
95}
96#[derive(serde::Serialize, serde::Deserialize)]
97#[serde(rename_all = "snake_case")]
98#[derive(Clone, PartialEq, ::prost::Message)]
99pub struct InternalTargetServiceGetTargetsResponse {
100    #[prost(message, repeated, tag = "1")]
101    pub targets: ::prost::alloc::vec::Vec<TargetResponse>,
102}
103#[derive(serde::Serialize, serde::Deserialize)]
104#[serde(rename_all = "snake_case")]
105#[derive(Clone, PartialEq, ::prost::Message)]
106pub struct InternalGetTargetsRequestFilter {
107    #[prost(uint32, repeated, tag = "1")]
108    pub company_ids: ::prost::alloc::vec::Vec<u32>,
109    #[prost(enumeration = "ArchivingFormatId", repeated, tag = "2")]
110    pub format_id: ::prost::alloc::vec::Vec<i32>,
111    #[prost(bool, optional, tag = "3")]
112    pub is_active: ::core::option::Option<bool>,
113}
114#[derive(serde::Serialize, serde::Deserialize)]
115#[serde(rename_all = "snake_case")]
116#[derive(Clone, Copy, PartialEq, ::prost::Message)]
117pub struct TargetResponseOrder {
118    #[prost(enumeration = "OrderBy", optional, tag = "1")]
119    pub order_by: ::core::option::Option<i32>,
120    #[prost(enumeration = "OrderDirection", optional, tag = "2")]
121    pub order_direction: ::core::option::Option<i32>,
122}
123#[derive(serde::Serialize, serde::Deserialize)]
124#[serde(rename_all = "snake_case")]
125#[derive(Clone, PartialEq, ::prost::Message)]
126pub struct TargetResponse {
127    #[prost(uint32, tag = "1")]
128    pub company_id: u32,
129    #[prost(message, optional, tag = "2")]
130    pub target: ::core::option::Option<Target>,
131    #[prost(message, optional, tag = "3")]
132    pub additional_target_properties: ::core::option::Option<
133        InternalAdditionalTargetProperties,
134    >,
135}
136#[derive(serde::Serialize, serde::Deserialize)]
137#[serde(rename_all = "snake_case")]
138#[derive(Clone, PartialEq, ::prost::Message)]
139pub struct InternalAdditionalTargetProperties {
140    #[prost(string, optional, tag = "1")]
141    pub bucket_v2: ::core::option::Option<::prost::alloc::string::String>,
142}
143#[derive(serde::Serialize, serde::Deserialize)]
144#[serde(rename_all = "snake_case")]
145#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
146#[repr(i32)]
147pub enum ArchivingFormatId {
148    Unspecified = 0,
149    WideParquetV1 = 1,
150}
151impl ArchivingFormatId {
152    /// String value of the enum field names used in the ProtoBuf definition.
153    ///
154    /// The values are not transformed in any way and thus are considered stable
155    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
156    pub fn as_str_name(&self) -> &'static str {
157        match self {
158            Self::Unspecified => "ARCHIVING_FORMAT_ID_UNSPECIFIED",
159            Self::WideParquetV1 => "ARCHIVING_FORMAT_ID_WIDE_PARQUET_V1",
160        }
161    }
162    /// Creates an enum from field names used in the ProtoBuf definition.
163    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
164        match value {
165            "ARCHIVING_FORMAT_ID_UNSPECIFIED" => Some(Self::Unspecified),
166            "ARCHIVING_FORMAT_ID_WIDE_PARQUET_V1" => Some(Self::WideParquetV1),
167            _ => None,
168        }
169    }
170}
171#[derive(serde::Serialize, serde::Deserialize)]
172#[serde(rename_all = "snake_case")]
173#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
174#[repr(i32)]
175pub enum OrderBy {
176    Unspecified = 0,
177    UpdatedAt = 1,
178    CreatedAt = 2,
179    CompanyId = 3,
180}
181impl OrderBy {
182    /// String value of the enum field names used in the ProtoBuf definition.
183    ///
184    /// The values are not transformed in any way and thus are considered stable
185    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
186    pub fn as_str_name(&self) -> &'static str {
187        match self {
188            Self::Unspecified => "ORDER_BY_UNSPECIFIED",
189            Self::UpdatedAt => "ORDER_BY_UPDATED_AT",
190            Self::CreatedAt => "ORDER_BY_CREATED_AT",
191            Self::CompanyId => "ORDER_BY_COMPANY_ID",
192        }
193    }
194    /// Creates an enum from field names used in the ProtoBuf definition.
195    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
196        match value {
197            "ORDER_BY_UNSPECIFIED" => Some(Self::Unspecified),
198            "ORDER_BY_UPDATED_AT" => Some(Self::UpdatedAt),
199            "ORDER_BY_CREATED_AT" => Some(Self::CreatedAt),
200            "ORDER_BY_COMPANY_ID" => Some(Self::CompanyId),
201            _ => None,
202        }
203    }
204}
205#[derive(serde::Serialize, serde::Deserialize)]
206#[serde(rename_all = "snake_case")]
207#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
208#[repr(i32)]
209pub enum OrderDirection {
210    Unspecified = 0,
211    Asc = 1,
212    Desc = 2,
213}
214impl OrderDirection {
215    /// String value of the enum field names used in the ProtoBuf definition.
216    ///
217    /// The values are not transformed in any way and thus are considered stable
218    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
219    pub fn as_str_name(&self) -> &'static str {
220        match self {
221            Self::Unspecified => "ORDER_DIRECTION_UNSPECIFIED",
222            Self::Asc => "ORDER_DIRECTION_ASC",
223            Self::Desc => "ORDER_DIRECTION_DESC",
224        }
225    }
226    /// Creates an enum from field names used in the ProtoBuf definition.
227    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
228        match value {
229            "ORDER_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
230            "ORDER_DIRECTION_ASC" => Some(Self::Asc),
231            "ORDER_DIRECTION_DESC" => Some(Self::Desc),
232            _ => None,
233        }
234    }
235}
236#[derive(serde::Serialize, serde::Deserialize)]
237#[serde(rename_all = "snake_case")]
238#[derive(Clone, Copy, PartialEq, ::prost::Message)]
239pub struct GetTargetRequest {}
240#[derive(serde::Serialize, serde::Deserialize)]
241#[serde(rename_all = "snake_case")]
242#[derive(Clone, PartialEq, ::prost::Message)]
243pub struct GetTargetResponse {
244    #[prost(message, optional, tag = "1")]
245    pub target: ::core::option::Option<Target>,
246}
247#[derive(serde::Serialize, serde::Deserialize)]
248#[serde(rename_all = "snake_case")]
249#[derive(Clone, PartialEq, ::prost::Message)]
250pub struct SetTargetRequest {
251    #[prost(bool, tag = "1")]
252    pub is_active: bool,
253    #[prost(oneof = "set_target_request::TargetSpec", tags = "2, 3")]
254    pub target_spec: ::core::option::Option<set_target_request::TargetSpec>,
255}
256/// Nested message and enum types in `SetTargetRequest`.
257pub mod set_target_request {
258    #[derive(serde::Serialize, serde::Deserialize)]
259    #[serde(rename_all = "snake_case")]
260    #[derive(Clone, PartialEq, ::prost::Oneof)]
261    pub enum TargetSpec {
262        #[prost(message, tag = "2")]
263        S3(super::S3TargetSpec),
264        #[prost(message, tag = "3")]
265        IbmCos(super::IbmCosTargetSpec),
266    }
267}
268#[derive(serde::Serialize, serde::Deserialize)]
269#[serde(rename_all = "snake_case")]
270#[derive(Clone, PartialEq, ::prost::Message)]
271pub struct SetTargetResponse {
272    #[prost(message, optional, tag = "1")]
273    pub target: ::core::option::Option<Target>,
274}
275#[derive(serde::Serialize, serde::Deserialize)]
276#[serde(rename_all = "snake_case")]
277#[derive(Clone, PartialEq, ::prost::Message)]
278pub struct SetExternalTargetRequest {
279    #[prost(bool, tag = "1")]
280    pub is_active: bool,
281    #[prost(uint32, tag = "4")]
282    pub company_id: u32,
283    #[prost(oneof = "set_external_target_request::TargetSpec", tags = "2, 3")]
284    pub target_spec: ::core::option::Option<set_external_target_request::TargetSpec>,
285}
286/// Nested message and enum types in `SetExternalTargetRequest`.
287pub mod set_external_target_request {
288    #[derive(serde::Serialize, serde::Deserialize)]
289    #[serde(rename_all = "snake_case")]
290    #[derive(Clone, PartialEq, ::prost::Oneof)]
291    pub enum TargetSpec {
292        #[prost(message, tag = "2")]
293        S3(super::S3TargetSpec),
294        #[prost(message, tag = "3")]
295        IbmCos(super::IbmCosTargetSpec),
296    }
297}
298#[derive(serde::Serialize, serde::Deserialize)]
299#[serde(rename_all = "snake_case")]
300#[derive(Clone, PartialEq, ::prost::Message)]
301pub struct SetExternalTargetResponse {
302    #[prost(message, optional, tag = "1")]
303    pub target: ::core::option::Option<Target>,
304}
305#[derive(serde::Serialize, serde::Deserialize)]
306#[serde(rename_all = "snake_case")]
307#[derive(Clone, Copy, PartialEq, ::prost::Message)]
308pub struct CompanyArchiveConfig {
309    #[prost(uint32, tag = "1")]
310    pub company_id: u32,
311    #[prost(bool, tag = "2")]
312    pub archive_configured: bool,
313}
314#[derive(serde::Serialize, serde::Deserialize)]
315#[serde(rename_all = "snake_case")]
316#[derive(Clone, PartialEq, ::prost::Message)]
317pub struct ValidateTargetRequest {
318    #[prost(bool, tag = "1")]
319    pub is_active: bool,
320    #[prost(oneof = "validate_target_request::TargetSpec", tags = "2, 3")]
321    pub target_spec: ::core::option::Option<validate_target_request::TargetSpec>,
322}
323/// Nested message and enum types in `ValidateTargetRequest`.
324pub mod validate_target_request {
325    #[derive(serde::Serialize, serde::Deserialize)]
326    #[serde(rename_all = "snake_case")]
327    #[derive(Clone, PartialEq, ::prost::Oneof)]
328    pub enum TargetSpec {
329        #[prost(message, tag = "2")]
330        S3(super::S3TargetSpec),
331        #[prost(message, tag = "3")]
332        IbmCos(super::IbmCosTargetSpec),
333    }
334}
335#[derive(serde::Serialize, serde::Deserialize)]
336#[serde(rename_all = "snake_case")]
337#[derive(Clone, Copy, PartialEq, ::prost::Message)]
338pub struct ValidateTargetResponse {
339    #[prost(bool, tag = "1")]
340    pub is_valid: bool,
341}
342/// Generated client implementations.
343pub mod target_service_client {
344    #![allow(
345        unused_variables,
346        dead_code,
347        missing_docs,
348        clippy::wildcard_imports,
349        clippy::let_unit_value,
350    )]
351    use tonic::codegen::*;
352    use tonic::codegen::http::Uri;
353    #[derive(Debug, Clone)]
354    pub struct TargetServiceClient<T> {
355        inner: tonic::client::Grpc<T>,
356    }
357    impl TargetServiceClient<tonic::transport::Channel> {
358        /// Attempt to create a new client by connecting to a given endpoint.
359        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
360        where
361            D: TryInto<tonic::transport::Endpoint>,
362            D::Error: Into<StdError>,
363        {
364            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
365            Ok(Self::new(conn))
366        }
367    }
368    impl<T> TargetServiceClient<T>
369    where
370        T: tonic::client::GrpcService<tonic::body::BoxBody>,
371        T::Error: Into<StdError>,
372        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
373        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
374    {
375        pub fn new(inner: T) -> Self {
376            let inner = tonic::client::Grpc::new(inner);
377            Self { inner }
378        }
379        pub fn with_origin(inner: T, origin: Uri) -> Self {
380            let inner = tonic::client::Grpc::with_origin(inner, origin);
381            Self { inner }
382        }
383        pub fn with_interceptor<F>(
384            inner: T,
385            interceptor: F,
386        ) -> TargetServiceClient<InterceptedService<T, F>>
387        where
388            F: tonic::service::Interceptor,
389            T::ResponseBody: Default,
390            T: tonic::codegen::Service<
391                http::Request<tonic::body::BoxBody>,
392                Response = http::Response<
393                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
394                >,
395            >,
396            <T as tonic::codegen::Service<
397                http::Request<tonic::body::BoxBody>,
398            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
399        {
400            TargetServiceClient::new(InterceptedService::new(inner, interceptor))
401        }
402        /// Compress requests with the given encoding.
403        ///
404        /// This requires the server to support it otherwise it might respond with an
405        /// error.
406        #[must_use]
407        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
408            self.inner = self.inner.send_compressed(encoding);
409            self
410        }
411        /// Enable decompressing responses.
412        #[must_use]
413        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
414            self.inner = self.inner.accept_compressed(encoding);
415            self
416        }
417        /// Limits the maximum size of a decoded message.
418        ///
419        /// Default: `4MB`
420        #[must_use]
421        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
422            self.inner = self.inner.max_decoding_message_size(limit);
423            self
424        }
425        /// Limits the maximum size of an encoded message.
426        ///
427        /// Default: `usize::MAX`
428        #[must_use]
429        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
430            self.inner = self.inner.max_encoding_message_size(limit);
431            self
432        }
433        pub async fn get_target(
434            &mut self,
435            request: impl tonic::IntoRequest<super::GetTargetRequest>,
436        ) -> std::result::Result<
437            tonic::Response<super::GetTargetResponse>,
438            tonic::Status,
439        > {
440            self.inner
441                .ready()
442                .await
443                .map_err(|e| {
444                    tonic::Status::unknown(
445                        format!("Service was not ready: {}", e.into()),
446                    )
447                })?;
448            let codec = tonic::codec::ProstCodec::default();
449            let path = http::uri::PathAndQuery::from_static(
450                "/com.coralogix.archive.v2.TargetService/GetTarget",
451            );
452            let mut req = request.into_request();
453            req.extensions_mut()
454                .insert(
455                    GrpcMethod::new(
456                        "com.coralogix.archive.v2.TargetService",
457                        "GetTarget",
458                    ),
459                );
460            self.inner.unary(req, path, codec).await
461        }
462        pub async fn set_target(
463            &mut self,
464            request: impl tonic::IntoRequest<super::SetTargetRequest>,
465        ) -> std::result::Result<
466            tonic::Response<super::SetTargetResponse>,
467            tonic::Status,
468        > {
469            self.inner
470                .ready()
471                .await
472                .map_err(|e| {
473                    tonic::Status::unknown(
474                        format!("Service was not ready: {}", e.into()),
475                    )
476                })?;
477            let codec = tonic::codec::ProstCodec::default();
478            let path = http::uri::PathAndQuery::from_static(
479                "/com.coralogix.archive.v2.TargetService/SetTarget",
480            );
481            let mut req = request.into_request();
482            req.extensions_mut()
483                .insert(
484                    GrpcMethod::new(
485                        "com.coralogix.archive.v2.TargetService",
486                        "SetTarget",
487                    ),
488                );
489            self.inner.unary(req, path, codec).await
490        }
491        pub async fn validate_target(
492            &mut self,
493            request: impl tonic::IntoRequest<super::ValidateTargetRequest>,
494        ) -> std::result::Result<
495            tonic::Response<super::ValidateTargetResponse>,
496            tonic::Status,
497        > {
498            self.inner
499                .ready()
500                .await
501                .map_err(|e| {
502                    tonic::Status::unknown(
503                        format!("Service was not ready: {}", e.into()),
504                    )
505                })?;
506            let codec = tonic::codec::ProstCodec::default();
507            let path = http::uri::PathAndQuery::from_static(
508                "/com.coralogix.archive.v2.TargetService/ValidateTarget",
509            );
510            let mut req = request.into_request();
511            req.extensions_mut()
512                .insert(
513                    GrpcMethod::new(
514                        "com.coralogix.archive.v2.TargetService",
515                        "ValidateTarget",
516                    ),
517                );
518            self.inner.unary(req, path, codec).await
519        }
520    }
521}
522/// Generated client implementations.
523pub mod internal_target_service_client {
524    #![allow(
525        unused_variables,
526        dead_code,
527        missing_docs,
528        clippy::wildcard_imports,
529        clippy::let_unit_value,
530    )]
531    use tonic::codegen::*;
532    use tonic::codegen::http::Uri;
533    #[derive(Debug, Clone)]
534    pub struct InternalTargetServiceClient<T> {
535        inner: tonic::client::Grpc<T>,
536    }
537    impl InternalTargetServiceClient<tonic::transport::Channel> {
538        /// Attempt to create a new client by connecting to a given endpoint.
539        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
540        where
541            D: TryInto<tonic::transport::Endpoint>,
542            D::Error: Into<StdError>,
543        {
544            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
545            Ok(Self::new(conn))
546        }
547    }
548    impl<T> InternalTargetServiceClient<T>
549    where
550        T: tonic::client::GrpcService<tonic::body::BoxBody>,
551        T::Error: Into<StdError>,
552        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
553        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
554    {
555        pub fn new(inner: T) -> Self {
556            let inner = tonic::client::Grpc::new(inner);
557            Self { inner }
558        }
559        pub fn with_origin(inner: T, origin: Uri) -> Self {
560            let inner = tonic::client::Grpc::with_origin(inner, origin);
561            Self { inner }
562        }
563        pub fn with_interceptor<F>(
564            inner: T,
565            interceptor: F,
566        ) -> InternalTargetServiceClient<InterceptedService<T, F>>
567        where
568            F: tonic::service::Interceptor,
569            T::ResponseBody: Default,
570            T: tonic::codegen::Service<
571                http::Request<tonic::body::BoxBody>,
572                Response = http::Response<
573                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
574                >,
575            >,
576            <T as tonic::codegen::Service<
577                http::Request<tonic::body::BoxBody>,
578            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
579        {
580            InternalTargetServiceClient::new(InterceptedService::new(inner, interceptor))
581        }
582        /// Compress requests with the given encoding.
583        ///
584        /// This requires the server to support it otherwise it might respond with an
585        /// error.
586        #[must_use]
587        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
588            self.inner = self.inner.send_compressed(encoding);
589            self
590        }
591        /// Enable decompressing responses.
592        #[must_use]
593        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
594            self.inner = self.inner.accept_compressed(encoding);
595            self
596        }
597        /// Limits the maximum size of a decoded message.
598        ///
599        /// Default: `4MB`
600        #[must_use]
601        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
602            self.inner = self.inner.max_decoding_message_size(limit);
603            self
604        }
605        /// Limits the maximum size of an encoded message.
606        ///
607        /// Default: `usize::MAX`
608        #[must_use]
609        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
610            self.inner = self.inner.max_encoding_message_size(limit);
611            self
612        }
613        pub async fn get_targets(
614            &mut self,
615            request: impl tonic::IntoRequest<
616                super::InternalTargetServiceGetTargetsRequest,
617            >,
618        ) -> std::result::Result<
619            tonic::Response<super::InternalTargetServiceGetTargetsResponse>,
620            tonic::Status,
621        > {
622            self.inner
623                .ready()
624                .await
625                .map_err(|e| {
626                    tonic::Status::unknown(
627                        format!("Service was not ready: {}", e.into()),
628                    )
629                })?;
630            let codec = tonic::codec::ProstCodec::default();
631            let path = http::uri::PathAndQuery::from_static(
632                "/com.coralogix.archive.v2.InternalTargetService/GetTargets",
633            );
634            let mut req = request.into_request();
635            req.extensions_mut()
636                .insert(
637                    GrpcMethod::new(
638                        "com.coralogix.archive.v2.InternalTargetService",
639                        "GetTargets",
640                    ),
641                );
642            self.inner.unary(req, path, codec).await
643        }
644        pub async fn set_external_target(
645            &mut self,
646            request: impl tonic::IntoRequest<super::SetExternalTargetRequest>,
647        ) -> std::result::Result<
648            tonic::Response<super::SetExternalTargetResponse>,
649            tonic::Status,
650        > {
651            self.inner
652                .ready()
653                .await
654                .map_err(|e| {
655                    tonic::Status::unknown(
656                        format!("Service was not ready: {}", e.into()),
657                    )
658                })?;
659            let codec = tonic::codec::ProstCodec::default();
660            let path = http::uri::PathAndQuery::from_static(
661                "/com.coralogix.archive.v2.InternalTargetService/SetExternalTarget",
662            );
663            let mut req = request.into_request();
664            req.extensions_mut()
665                .insert(
666                    GrpcMethod::new(
667                        "com.coralogix.archive.v2.InternalTargetService",
668                        "SetExternalTarget",
669                    ),
670                );
671            self.inner.unary(req, path, codec).await
672        }
673    }
674}
cx_api/generated/com.coralogix.archive.v2.rs

cx_api/generated/
com.coralogix.archive.v2.rs
