cometbft_proto/prost/
cometbft.services.pruning.v1.rs

1/// SetBlockRetainHeightRequest sets the retain height for blocks.
2#[allow(clippy::derive_partial_eq_without_eq)]
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct SetBlockRetainHeightRequest {
5    #[prost(uint64, tag = "1")]
6    pub height: u64,
7}
8/// SetBlockRetainHeightResponse is empty.
9#[allow(clippy::derive_partial_eq_without_eq)]
10#[derive(Clone, PartialEq, ::prost::Message)]
11pub struct SetBlockRetainHeightResponse {}
12/// GetBlockRetainHeightRequest is a request for the retain height.
13#[allow(clippy::derive_partial_eq_without_eq)]
14#[derive(Clone, PartialEq, ::prost::Message)]
15pub struct GetBlockRetainHeightRequest {}
16/// GetBlockRetainHeightResponse returns the retain height for blocks.
17#[allow(clippy::derive_partial_eq_without_eq)]
18#[derive(Clone, PartialEq, ::prost::Message)]
19pub struct GetBlockRetainHeightResponse {
20    /// The retain height set by the application.
21    #[prost(uint64, tag = "1")]
22    pub app_retain_height: u64,
23    /// The retain height set via the pruning service (e.g. by the data
24    /// companion) specifically for blocks.
25    #[prost(uint64, tag = "2")]
26    pub pruning_service_retain_height: u64,
27}
28/// SetBlockResultsRetainHeightRequest sets the retain height for block results.
29#[allow(clippy::derive_partial_eq_without_eq)]
30#[derive(Clone, PartialEq, ::prost::Message)]
31pub struct SetBlockResultsRetainHeightRequest {
32    #[prost(uint64, tag = "1")]
33    pub height: u64,
34}
35/// SetBlockResultsRetainHeightResponse is empty.
36#[allow(clippy::derive_partial_eq_without_eq)]
37#[derive(Clone, PartialEq, ::prost::Message)]
38pub struct SetBlockResultsRetainHeightResponse {}
39/// GetBlockResultsRetainHeightRequest is a request for the retain height.
40#[allow(clippy::derive_partial_eq_without_eq)]
41#[derive(Clone, PartialEq, ::prost::Message)]
42pub struct GetBlockResultsRetainHeightRequest {}
43/// GetBlockResultsRetainHeightResponse returns the retain height for block results.
44#[allow(clippy::derive_partial_eq_without_eq)]
45#[derive(Clone, PartialEq, ::prost::Message)]
46pub struct GetBlockResultsRetainHeightResponse {
47    /// The retain height set by the pruning service (e.g. by the data
48    /// companion) specifically for block results.
49    #[prost(uint64, tag = "1")]
50    pub pruning_service_retain_height: u64,
51}
52/// SetTxIndexerRetainHeightRequest sets the retain height for the tx indexer.
53#[allow(clippy::derive_partial_eq_without_eq)]
54#[derive(Clone, PartialEq, ::prost::Message)]
55pub struct SetTxIndexerRetainHeightRequest {
56    #[prost(uint64, tag = "1")]
57    pub height: u64,
58}
59/// SetTxIndexerRetainHeightResponse is empty.
60#[allow(clippy::derive_partial_eq_without_eq)]
61#[derive(Clone, PartialEq, ::prost::Message)]
62pub struct SetTxIndexerRetainHeightResponse {}
63/// GetTxIndexerRetainHeightRequest is a request for the retain height.
64#[allow(clippy::derive_partial_eq_without_eq)]
65#[derive(Clone, PartialEq, ::prost::Message)]
66pub struct GetTxIndexerRetainHeightRequest {}
67/// GetTxIndexerRetainHeightResponse returns the retain height for the tx indexer.
68#[allow(clippy::derive_partial_eq_without_eq)]
69#[derive(Clone, PartialEq, ::prost::Message)]
70pub struct GetTxIndexerRetainHeightResponse {
71    #[prost(uint64, tag = "1")]
72    pub height: u64,
73}
74/// SetBlockIndexerRetainHeightRequest sets the retain height for the block indexer.
75#[allow(clippy::derive_partial_eq_without_eq)]
76#[derive(Clone, PartialEq, ::prost::Message)]
77pub struct SetBlockIndexerRetainHeightRequest {
78    #[prost(uint64, tag = "1")]
79    pub height: u64,
80}
81/// SetBlockIndexerRetainHeightResponse is empty.
82#[allow(clippy::derive_partial_eq_without_eq)]
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct SetBlockIndexerRetainHeightResponse {}
85/// GetBlockIndexerRetainHeightRequest is a request for the retain height.
86#[allow(clippy::derive_partial_eq_without_eq)]
87#[derive(Clone, PartialEq, ::prost::Message)]
88pub struct GetBlockIndexerRetainHeightRequest {}
89/// GetBlockIndexerRetainHeightResponse returns the retain height for the block indexer.
90#[allow(clippy::derive_partial_eq_without_eq)]
91#[derive(Clone, PartialEq, ::prost::Message)]
92pub struct GetBlockIndexerRetainHeightResponse {
93    #[prost(uint64, tag = "1")]
94    pub height: u64,
95}
96/// Generated server implementations.
97#[cfg(feature = "grpc-server")]
98pub mod pruning_service_server {
99    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
100    use tonic::codegen::*;
101    /// Generated trait containing gRPC methods that should be implemented for use with PruningServiceServer.
102    #[async_trait]
103    pub trait PruningService: Send + Sync + 'static {
104        /// SetBlockRetainHeightRequest indicates to the node that it can safely
105        /// prune all block data up to the specified retain height.
106        ///
107        /// The lower of this retain height and that set by the application in its
108        /// Commit response will be used by the node to determine which heights' data
109        /// can be pruned.
110        async fn set_block_retain_height(
111            &self,
112            request: tonic::Request<super::SetBlockRetainHeightRequest>,
113        ) -> std::result::Result<
114            tonic::Response<super::SetBlockRetainHeightResponse>,
115            tonic::Status,
116        >;
117        /// GetBlockRetainHeight returns information about the retain height
118        /// parameters used by the node to influence block retention/pruning.
119        async fn get_block_retain_height(
120            &self,
121            request: tonic::Request<super::GetBlockRetainHeightRequest>,
122        ) -> std::result::Result<
123            tonic::Response<super::GetBlockRetainHeightResponse>,
124            tonic::Status,
125        >;
126        /// SetBlockResultsRetainHeightRequest indicates to the node that it can
127        /// safely prune all block results data up to the specified height.
128        ///
129        /// The node will always store the block results for the latest height to
130        /// help facilitate crash recovery.
131        async fn set_block_results_retain_height(
132            &self,
133            request: tonic::Request<super::SetBlockResultsRetainHeightRequest>,
134        ) -> std::result::Result<
135            tonic::Response<super::SetBlockResultsRetainHeightResponse>,
136            tonic::Status,
137        >;
138        /// GetBlockResultsRetainHeight returns information about the retain height
139        /// parameters used by the node to influence block results retention/pruning.
140        async fn get_block_results_retain_height(
141            &self,
142            request: tonic::Request<super::GetBlockResultsRetainHeightRequest>,
143        ) -> std::result::Result<
144            tonic::Response<super::GetBlockResultsRetainHeightResponse>,
145            tonic::Status,
146        >;
147        /// SetTxIndexerRetainHeightRequest indicates to the node that it can safely
148        /// prune all tx indices up to the specified retain height.
149        async fn set_tx_indexer_retain_height(
150            &self,
151            request: tonic::Request<super::SetTxIndexerRetainHeightRequest>,
152        ) -> std::result::Result<
153            tonic::Response<super::SetTxIndexerRetainHeightResponse>,
154            tonic::Status,
155        >;
156        /// GetTxIndexerRetainHeight returns information about the retain height
157        /// parameters used by the node to influence TxIndexer pruning
158        async fn get_tx_indexer_retain_height(
159            &self,
160            request: tonic::Request<super::GetTxIndexerRetainHeightRequest>,
161        ) -> std::result::Result<
162            tonic::Response<super::GetTxIndexerRetainHeightResponse>,
163            tonic::Status,
164        >;
165        /// SetBlockIndexerRetainHeightRequest indicates to the node that it can safely
166        /// prune all block indices up to the specified retain height.
167        async fn set_block_indexer_retain_height(
168            &self,
169            request: tonic::Request<super::SetBlockIndexerRetainHeightRequest>,
170        ) -> std::result::Result<
171            tonic::Response<super::SetBlockIndexerRetainHeightResponse>,
172            tonic::Status,
173        >;
174        /// GetBlockIndexerRetainHeight returns information about the retain height
175        /// parameters used by the node to influence BlockIndexer pruning
176        async fn get_block_indexer_retain_height(
177            &self,
178            request: tonic::Request<super::GetBlockIndexerRetainHeightRequest>,
179        ) -> std::result::Result<
180            tonic::Response<super::GetBlockIndexerRetainHeightResponse>,
181            tonic::Status,
182        >;
183    }
184    /// PruningService provides privileged access to specialized pruning
185    /// functionality on the CometBFT node to help control node storage.
186    #[derive(Debug)]
187    pub struct PruningServiceServer<T: PruningService> {
188        inner: _Inner<T>,
189        accept_compression_encodings: EnabledCompressionEncodings,
190        send_compression_encodings: EnabledCompressionEncodings,
191        max_decoding_message_size: Option<usize>,
192        max_encoding_message_size: Option<usize>,
193    }
194    struct _Inner<T>(Arc<T>);
195    impl<T: PruningService> PruningServiceServer<T> {
196        pub fn new(inner: T) -> Self {
197            Self::from_arc(Arc::new(inner))
198        }
199        pub fn from_arc(inner: Arc<T>) -> Self {
200            let inner = _Inner(inner);
201            Self {
202                inner,
203                accept_compression_encodings: Default::default(),
204                send_compression_encodings: Default::default(),
205                max_decoding_message_size: None,
206                max_encoding_message_size: None,
207            }
208        }
209        pub fn with_interceptor<F>(
210            inner: T,
211            interceptor: F,
212        ) -> InterceptedService<Self, F>
213        where
214            F: tonic::service::Interceptor,
215        {
216            InterceptedService::new(Self::new(inner), interceptor)
217        }
218        /// Enable decompressing requests with the given encoding.
219        #[must_use]
220        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
221            self.accept_compression_encodings.enable(encoding);
222            self
223        }
224        /// Compress responses with the given encoding, if the client supports it.
225        #[must_use]
226        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
227            self.send_compression_encodings.enable(encoding);
228            self
229        }
230        /// Limits the maximum size of a decoded message.
231        ///
232        /// Default: `4MB`
233        #[must_use]
234        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
235            self.max_decoding_message_size = Some(limit);
236            self
237        }
238        /// Limits the maximum size of an encoded message.
239        ///
240        /// Default: `usize::MAX`
241        #[must_use]
242        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
243            self.max_encoding_message_size = Some(limit);
244            self
245        }
246    }
247    impl<T, B> tonic::codegen::Service<http::Request<B>> for PruningServiceServer<T>
248    where
249        T: PruningService,
250        B: Body + Send + 'static,
251        B::Error: Into<StdError> + Send + 'static,
252    {
253        type Response = http::Response<tonic::body::BoxBody>;
254        type Error = std::convert::Infallible;
255        type Future = BoxFuture<Self::Response, Self::Error>;
256        fn poll_ready(
257            &mut self,
258            _cx: &mut Context<'_>,
259        ) -> Poll<std::result::Result<(), Self::Error>> {
260            Poll::Ready(Ok(()))
261        }
262        fn call(&mut self, req: http::Request<B>) -> Self::Future {
263            let inner = self.inner.clone();
264            match req.uri().path() {
265                "/cometbft.services.pruning.v1.PruningService/SetBlockRetainHeight" => {
266                    #[allow(non_camel_case_types)]
267                    struct SetBlockRetainHeightSvc<T: PruningService>(pub Arc<T>);
268                    impl<
269                        T: PruningService,
270                    > tonic::server::UnaryService<super::SetBlockRetainHeightRequest>
271                    for SetBlockRetainHeightSvc<T> {
272                        type Response = super::SetBlockRetainHeightResponse;
273                        type Future = BoxFuture<
274                            tonic::Response<Self::Response>,
275                            tonic::Status,
276                        >;
277                        fn call(
278                            &mut self,
279                            request: tonic::Request<super::SetBlockRetainHeightRequest>,
280                        ) -> Self::Future {
281                            let inner = Arc::clone(&self.0);
282                            let fut = async move {
283                                <T as PruningService>::set_block_retain_height(
284                                        &inner,
285                                        request,
286                                    )
287                                    .await
288                            };
289                            Box::pin(fut)
290                        }
291                    }
292                    let accept_compression_encodings = self.accept_compression_encodings;
293                    let send_compression_encodings = self.send_compression_encodings;
294                    let max_decoding_message_size = self.max_decoding_message_size;
295                    let max_encoding_message_size = self.max_encoding_message_size;
296                    let inner = self.inner.clone();
297                    let fut = async move {
298                        let inner = inner.0;
299                        let method = SetBlockRetainHeightSvc(inner);
300                        let codec = tonic::codec::ProstCodec::default();
301                        let mut grpc = tonic::server::Grpc::new(codec)
302                            .apply_compression_config(
303                                accept_compression_encodings,
304                                send_compression_encodings,
305                            )
306                            .apply_max_message_size_config(
307                                max_decoding_message_size,
308                                max_encoding_message_size,
309                            );
310                        let res = grpc.unary(method, req).await;
311                        Ok(res)
312                    };
313                    Box::pin(fut)
314                }
315                "/cometbft.services.pruning.v1.PruningService/GetBlockRetainHeight" => {
316                    #[allow(non_camel_case_types)]
317                    struct GetBlockRetainHeightSvc<T: PruningService>(pub Arc<T>);
318                    impl<
319                        T: PruningService,
320                    > tonic::server::UnaryService<super::GetBlockRetainHeightRequest>
321                    for GetBlockRetainHeightSvc<T> {
322                        type Response = super::GetBlockRetainHeightResponse;
323                        type Future = BoxFuture<
324                            tonic::Response<Self::Response>,
325                            tonic::Status,
326                        >;
327                        fn call(
328                            &mut self,
329                            request: tonic::Request<super::GetBlockRetainHeightRequest>,
330                        ) -> Self::Future {
331                            let inner = Arc::clone(&self.0);
332                            let fut = async move {
333                                <T as PruningService>::get_block_retain_height(
334                                        &inner,
335                                        request,
336                                    )
337                                    .await
338                            };
339                            Box::pin(fut)
340                        }
341                    }
342                    let accept_compression_encodings = self.accept_compression_encodings;
343                    let send_compression_encodings = self.send_compression_encodings;
344                    let max_decoding_message_size = self.max_decoding_message_size;
345                    let max_encoding_message_size = self.max_encoding_message_size;
346                    let inner = self.inner.clone();
347                    let fut = async move {
348                        let inner = inner.0;
349                        let method = GetBlockRetainHeightSvc(inner);
350                        let codec = tonic::codec::ProstCodec::default();
351                        let mut grpc = tonic::server::Grpc::new(codec)
352                            .apply_compression_config(
353                                accept_compression_encodings,
354                                send_compression_encodings,
355                            )
356                            .apply_max_message_size_config(
357                                max_decoding_message_size,
358                                max_encoding_message_size,
359                            );
360                        let res = grpc.unary(method, req).await;
361                        Ok(res)
362                    };
363                    Box::pin(fut)
364                }
365                "/cometbft.services.pruning.v1.PruningService/SetBlockResultsRetainHeight" => {
366                    #[allow(non_camel_case_types)]
367                    struct SetBlockResultsRetainHeightSvc<T: PruningService>(pub Arc<T>);
368                    impl<
369                        T: PruningService,
370                    > tonic::server::UnaryService<
371                        super::SetBlockResultsRetainHeightRequest,
372                    > for SetBlockResultsRetainHeightSvc<T> {
373                        type Response = super::SetBlockResultsRetainHeightResponse;
374                        type Future = BoxFuture<
375                            tonic::Response<Self::Response>,
376                            tonic::Status,
377                        >;
378                        fn call(
379                            &mut self,
380                            request: tonic::Request<
381                                super::SetBlockResultsRetainHeightRequest,
382                            >,
383                        ) -> Self::Future {
384                            let inner = Arc::clone(&self.0);
385                            let fut = async move {
386                                <T as PruningService>::set_block_results_retain_height(
387                                        &inner,
388                                        request,
389                                    )
390                                    .await
391                            };
392                            Box::pin(fut)
393                        }
394                    }
395                    let accept_compression_encodings = self.accept_compression_encodings;
396                    let send_compression_encodings = self.send_compression_encodings;
397                    let max_decoding_message_size = self.max_decoding_message_size;
398                    let max_encoding_message_size = self.max_encoding_message_size;
399                    let inner = self.inner.clone();
400                    let fut = async move {
401                        let inner = inner.0;
402                        let method = SetBlockResultsRetainHeightSvc(inner);
403                        let codec = tonic::codec::ProstCodec::default();
404                        let mut grpc = tonic::server::Grpc::new(codec)
405                            .apply_compression_config(
406                                accept_compression_encodings,
407                                send_compression_encodings,
408                            )
409                            .apply_max_message_size_config(
410                                max_decoding_message_size,
411                                max_encoding_message_size,
412                            );
413                        let res = grpc.unary(method, req).await;
414                        Ok(res)
415                    };
416                    Box::pin(fut)
417                }
418                "/cometbft.services.pruning.v1.PruningService/GetBlockResultsRetainHeight" => {
419                    #[allow(non_camel_case_types)]
420                    struct GetBlockResultsRetainHeightSvc<T: PruningService>(pub Arc<T>);
421                    impl<
422                        T: PruningService,
423                    > tonic::server::UnaryService<
424                        super::GetBlockResultsRetainHeightRequest,
425                    > for GetBlockResultsRetainHeightSvc<T> {
426                        type Response = super::GetBlockResultsRetainHeightResponse;
427                        type Future = BoxFuture<
428                            tonic::Response<Self::Response>,
429                            tonic::Status,
430                        >;
431                        fn call(
432                            &mut self,
433                            request: tonic::Request<
434                                super::GetBlockResultsRetainHeightRequest,
435                            >,
436                        ) -> Self::Future {
437                            let inner = Arc::clone(&self.0);
438                            let fut = async move {
439                                <T as PruningService>::get_block_results_retain_height(
440                                        &inner,
441                                        request,
442                                    )
443                                    .await
444                            };
445                            Box::pin(fut)
446                        }
447                    }
448                    let accept_compression_encodings = self.accept_compression_encodings;
449                    let send_compression_encodings = self.send_compression_encodings;
450                    let max_decoding_message_size = self.max_decoding_message_size;
451                    let max_encoding_message_size = self.max_encoding_message_size;
452                    let inner = self.inner.clone();
453                    let fut = async move {
454                        let inner = inner.0;
455                        let method = GetBlockResultsRetainHeightSvc(inner);
456                        let codec = tonic::codec::ProstCodec::default();
457                        let mut grpc = tonic::server::Grpc::new(codec)
458                            .apply_compression_config(
459                                accept_compression_encodings,
460                                send_compression_encodings,
461                            )
462                            .apply_max_message_size_config(
463                                max_decoding_message_size,
464                                max_encoding_message_size,
465                            );
466                        let res = grpc.unary(method, req).await;
467                        Ok(res)
468                    };
469                    Box::pin(fut)
470                }
471                "/cometbft.services.pruning.v1.PruningService/SetTxIndexerRetainHeight" => {
472                    #[allow(non_camel_case_types)]
473                    struct SetTxIndexerRetainHeightSvc<T: PruningService>(pub Arc<T>);
474                    impl<
475                        T: PruningService,
476                    > tonic::server::UnaryService<super::SetTxIndexerRetainHeightRequest>
477                    for SetTxIndexerRetainHeightSvc<T> {
478                        type Response = super::SetTxIndexerRetainHeightResponse;
479                        type Future = BoxFuture<
480                            tonic::Response<Self::Response>,
481                            tonic::Status,
482                        >;
483                        fn call(
484                            &mut self,
485                            request: tonic::Request<
486                                super::SetTxIndexerRetainHeightRequest,
487                            >,
488                        ) -> Self::Future {
489                            let inner = Arc::clone(&self.0);
490                            let fut = async move {
491                                <T as PruningService>::set_tx_indexer_retain_height(
492                                        &inner,
493                                        request,
494                                    )
495                                    .await
496                            };
497                            Box::pin(fut)
498                        }
499                    }
500                    let accept_compression_encodings = self.accept_compression_encodings;
501                    let send_compression_encodings = self.send_compression_encodings;
502                    let max_decoding_message_size = self.max_decoding_message_size;
503                    let max_encoding_message_size = self.max_encoding_message_size;
504                    let inner = self.inner.clone();
505                    let fut = async move {
506                        let inner = inner.0;
507                        let method = SetTxIndexerRetainHeightSvc(inner);
508                        let codec = tonic::codec::ProstCodec::default();
509                        let mut grpc = tonic::server::Grpc::new(codec)
510                            .apply_compression_config(
511                                accept_compression_encodings,
512                                send_compression_encodings,
513                            )
514                            .apply_max_message_size_config(
515                                max_decoding_message_size,
516                                max_encoding_message_size,
517                            );
518                        let res = grpc.unary(method, req).await;
519                        Ok(res)
520                    };
521                    Box::pin(fut)
522                }
523                "/cometbft.services.pruning.v1.PruningService/GetTxIndexerRetainHeight" => {
524                    #[allow(non_camel_case_types)]
525                    struct GetTxIndexerRetainHeightSvc<T: PruningService>(pub Arc<T>);
526                    impl<
527                        T: PruningService,
528                    > tonic::server::UnaryService<super::GetTxIndexerRetainHeightRequest>
529                    for GetTxIndexerRetainHeightSvc<T> {
530                        type Response = super::GetTxIndexerRetainHeightResponse;
531                        type Future = BoxFuture<
532                            tonic::Response<Self::Response>,
533                            tonic::Status,
534                        >;
535                        fn call(
536                            &mut self,
537                            request: tonic::Request<
538                                super::GetTxIndexerRetainHeightRequest,
539                            >,
540                        ) -> Self::Future {
541                            let inner = Arc::clone(&self.0);
542                            let fut = async move {
543                                <T as PruningService>::get_tx_indexer_retain_height(
544                                        &inner,
545                                        request,
546                                    )
547                                    .await
548                            };
549                            Box::pin(fut)
550                        }
551                    }
552                    let accept_compression_encodings = self.accept_compression_encodings;
553                    let send_compression_encodings = self.send_compression_encodings;
554                    let max_decoding_message_size = self.max_decoding_message_size;
555                    let max_encoding_message_size = self.max_encoding_message_size;
556                    let inner = self.inner.clone();
557                    let fut = async move {
558                        let inner = inner.0;
559                        let method = GetTxIndexerRetainHeightSvc(inner);
560                        let codec = tonic::codec::ProstCodec::default();
561                        let mut grpc = tonic::server::Grpc::new(codec)
562                            .apply_compression_config(
563                                accept_compression_encodings,
564                                send_compression_encodings,
565                            )
566                            .apply_max_message_size_config(
567                                max_decoding_message_size,
568                                max_encoding_message_size,
569                            );
570                        let res = grpc.unary(method, req).await;
571                        Ok(res)
572                    };
573                    Box::pin(fut)
574                }
575                "/cometbft.services.pruning.v1.PruningService/SetBlockIndexerRetainHeight" => {
576                    #[allow(non_camel_case_types)]
577                    struct SetBlockIndexerRetainHeightSvc<T: PruningService>(pub Arc<T>);
578                    impl<
579                        T: PruningService,
580                    > tonic::server::UnaryService<
581                        super::SetBlockIndexerRetainHeightRequest,
582                    > for SetBlockIndexerRetainHeightSvc<T> {
583                        type Response = super::SetBlockIndexerRetainHeightResponse;
584                        type Future = BoxFuture<
585                            tonic::Response<Self::Response>,
586                            tonic::Status,
587                        >;
588                        fn call(
589                            &mut self,
590                            request: tonic::Request<
591                                super::SetBlockIndexerRetainHeightRequest,
592                            >,
593                        ) -> Self::Future {
594                            let inner = Arc::clone(&self.0);
595                            let fut = async move {
596                                <T as PruningService>::set_block_indexer_retain_height(
597                                        &inner,
598                                        request,
599                                    )
600                                    .await
601                            };
602                            Box::pin(fut)
603                        }
604                    }
605                    let accept_compression_encodings = self.accept_compression_encodings;
606                    let send_compression_encodings = self.send_compression_encodings;
607                    let max_decoding_message_size = self.max_decoding_message_size;
608                    let max_encoding_message_size = self.max_encoding_message_size;
609                    let inner = self.inner.clone();
610                    let fut = async move {
611                        let inner = inner.0;
612                        let method = SetBlockIndexerRetainHeightSvc(inner);
613                        let codec = tonic::codec::ProstCodec::default();
614                        let mut grpc = tonic::server::Grpc::new(codec)
615                            .apply_compression_config(
616                                accept_compression_encodings,
617                                send_compression_encodings,
618                            )
619                            .apply_max_message_size_config(
620                                max_decoding_message_size,
621                                max_encoding_message_size,
622                            );
623                        let res = grpc.unary(method, req).await;
624                        Ok(res)
625                    };
626                    Box::pin(fut)
627                }
628                "/cometbft.services.pruning.v1.PruningService/GetBlockIndexerRetainHeight" => {
629                    #[allow(non_camel_case_types)]
630                    struct GetBlockIndexerRetainHeightSvc<T: PruningService>(pub Arc<T>);
631                    impl<
632                        T: PruningService,
633                    > tonic::server::UnaryService<
634                        super::GetBlockIndexerRetainHeightRequest,
635                    > for GetBlockIndexerRetainHeightSvc<T> {
636                        type Response = super::GetBlockIndexerRetainHeightResponse;
637                        type Future = BoxFuture<
638                            tonic::Response<Self::Response>,
639                            tonic::Status,
640                        >;
641                        fn call(
642                            &mut self,
643                            request: tonic::Request<
644                                super::GetBlockIndexerRetainHeightRequest,
645                            >,
646                        ) -> Self::Future {
647                            let inner = Arc::clone(&self.0);
648                            let fut = async move {
649                                <T as PruningService>::get_block_indexer_retain_height(
650                                        &inner,
651                                        request,
652                                    )
653                                    .await
654                            };
655                            Box::pin(fut)
656                        }
657                    }
658                    let accept_compression_encodings = self.accept_compression_encodings;
659                    let send_compression_encodings = self.send_compression_encodings;
660                    let max_decoding_message_size = self.max_decoding_message_size;
661                    let max_encoding_message_size = self.max_encoding_message_size;
662                    let inner = self.inner.clone();
663                    let fut = async move {
664                        let inner = inner.0;
665                        let method = GetBlockIndexerRetainHeightSvc(inner);
666                        let codec = tonic::codec::ProstCodec::default();
667                        let mut grpc = tonic::server::Grpc::new(codec)
668                            .apply_compression_config(
669                                accept_compression_encodings,
670                                send_compression_encodings,
671                            )
672                            .apply_max_message_size_config(
673                                max_decoding_message_size,
674                                max_encoding_message_size,
675                            );
676                        let res = grpc.unary(method, req).await;
677                        Ok(res)
678                    };
679                    Box::pin(fut)
680                }
681                _ => {
682                    Box::pin(async move {
683                        Ok(
684                            http::Response::builder()
685                                .status(200)
686                                .header("grpc-status", "12")
687                                .header("content-type", "application/grpc")
688                                .body(empty_body())
689                                .unwrap(),
690                        )
691                    })
692                }
693            }
694        }
695    }
696    impl<T: PruningService> Clone for PruningServiceServer<T> {
697        fn clone(&self) -> Self {
698            let inner = self.inner.clone();
699            Self {
700                inner,
701                accept_compression_encodings: self.accept_compression_encodings,
702                send_compression_encodings: self.send_compression_encodings,
703                max_decoding_message_size: self.max_decoding_message_size,
704                max_encoding_message_size: self.max_encoding_message_size,
705            }
706        }
707    }
708    impl<T: PruningService> Clone for _Inner<T> {
709        fn clone(&self) -> Self {
710            Self(Arc::clone(&self.0))
711        }
712    }
713    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
714        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
715            write!(f, "{:?}", self.0)
716        }
717    }
718    impl<T: PruningService> tonic::server::NamedService for PruningServiceServer<T> {
719        const NAME: &'static str = "cometbft.services.pruning.v1.PruningService";
720    }
721}
cometbft_proto/prost/cometbft.services.pruning.v1.rs

cometbft_proto/prost/
cometbft.services.pruning.v1.rs
