Struct momento_protos::cache_client::pubsub::pubsub_server::PubsubServer

pub struct PubsubServer<T: Pubsub> { /* private fields */ }

For working with topics in a cache. Momento topics are conceptually located on a cache. They are best-effort multicast. To use them, create a cache then start subscribing and publishing!

Momento topic subscriptions try to give you information about the quality of the stream you are receiving. For example, you might miss messages if your network is slow, or if some intermediate switch fails, or due to rate limiting. It is also possible, though we try to avoid it, that messages could briefly come out of order between subscribers. We try to tell you when things like this happen via a Discontinuity in your subscription stream. If you do not care about occasional discontinuities then don’t bother handling them! You might still want to log them just in case ;-)

Implementations

impl<T: Pubsub> PubsubServer<T>

pub fn new(inner: T) -> Self

pub fn from_arc(inner: Arc<T>) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F ) -> InterceptedService<Self, F>where F: Interceptor,

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing requests with the given encoding.

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress responses with the given encoding, if the client supports it.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

Trait Implementations

impl<T: Pubsub> Clone for PubsubServer<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Pubsub> Debug for PubsubServer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Pubsub> NamedService for PubsubServer<T>

const NAME: &'static str = "cache_client.pubsub.Pubsub"

The Service-Name as described here.

impl<T, B> Service<Request<B>> for PubsubServer<T>where T: Pubsub, B: Body + Send + 'static, B::Error: Into<StdError> + Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Status>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<PubsubServer<T> as Service<Request<B>>>::Response, <PubsubServer<T> as Service<Request<B>>>::Error>> + Send, Global>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.