Struct ContentClient

pub struct ContentClient<T> { /* private fields */ }

Content provides access to a content addressable storage system.

Implementations

impl ContentClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> ContentClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> ContentClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

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

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

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

Enable decompressing responses.

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

pub async fn info( &mut self, request: impl IntoRequest<InfoRequest>, ) -> Result<Response<InfoResponse>, Status>

Info returns information about a committed object.

This call can be used for getting the size of content and checking for existence.

pub async fn update( &mut self, request: impl IntoRequest<UpdateRequest>, ) -> Result<Response<UpdateResponse>, Status>

Update updates content metadata.

This call can be used to manage the mutable content labels. The immutable metadata such as digest, size, and committed at cannot be updated.

pub async fn list( &mut self, request: impl IntoRequest<ListContentRequest>, ) -> Result<Response<Streaming<ListContentResponse>>, Status>

List streams the entire set of content as Info objects and closes the stream.

Typically, this will yield a large response, chunked into messages. Clients should make provisions to ensure they can handle the entire data set.

pub async fn delete( &mut self, request: impl IntoRequest<DeleteContentRequest>, ) -> Result<Response<()>, Status>

Delete will delete the referenced object.

pub async fn read( &mut self, request: impl IntoRequest<ReadContentRequest>, ) -> Result<Response<Streaming<ReadContentResponse>>, Status>

Read allows one to read an object based on the offset into the content.

The requested data may be returned in one or more messages.

pub async fn status( &mut self, request: impl IntoRequest<StatusRequest>, ) -> Result<Response<StatusResponse>, Status>

Status returns the status for a single reference.

pub async fn list_statuses( &mut self, request: impl IntoRequest<ListStatusesRequest>, ) -> Result<Response<ListStatusesResponse>, Status>

ListStatuses returns the status of ongoing object ingestions, started via Write.

Only those matching the regular expression will be provided in the response. If the provided regular expression is empty, all ingestions will be provided.

pub async fn write( &mut self, request: impl IntoStreamingRequest<Message = WriteContentRequest>, ) -> Result<Response<Streaming<WriteContentResponse>>, Status>

Write begins or resumes writes to a resource identified by a unique ref. Only one active stream may exist at a time for each ref.

Once a write stream has started, it may only write to a single ref, thus once a stream is started, the ref may be omitted on subsequent writes.

For any write transaction represented by a ref, only a single write may be made to a given offset. If overlapping writes occur, it is an error. Writes should be sequential and implementations may throw an error if this is required.

If expected_digest is set and already part of the content store, the write will fail.

When completed, the commit flag should be set to true. If expected size or digest is set, the content will be validated against those values.

pub async fn abort( &mut self, request: impl IntoRequest<AbortRequest>, ) -> Result<Response<()>, Status>

Abort cancels the ongoing write named in the request. Any resources associated with the write will be collected.

Trait Implementations

impl<T: Clone> Clone for ContentClient<T>

fn clone(&self) -> ContentClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ContentClient<T>

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

Formats the value using the given formatter.