Struct ChunkStoreServiceClient 

pub struct ChunkStoreServiceClient<T> {
    inner: Grpc<T>,
}

ChunkStoreService allows reading (or uploading) content-addressed chunks of raw data. BLAKE3 is used as a hashing function for the data. Uploading a blob will return the BLAKE3 digest of it, and that’s the identifier used to Read/Stat them too. Chunks are considered small enough to not require any further chunking, but may be broken down into smaller messages when sent as proto messages, due to message size restrictions.

Fields

inner: Grpc<T>

Implementations

impl ChunkStoreServiceClient<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> ChunkStoreServiceClient<T>

where T: GrpcService<Body>, 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, ) -> ChunkStoreServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<Body>, Response = Response<<T as GrpcService<Body>>::ResponseBody>>, <T as Service<Request<Body>>>::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 stat_chunk( &mut self, request: impl IntoRequest<StatChunkRequest>, ) -> Result<Response<StatChunkResponse>, Status>

Stat can be used to check for the existence of a chunk.

pub async fn get_chunk( &mut self, request: impl IntoRequest<GetChunkRequest>, ) -> Result<Response<Streaming<GetChunkResponse>>, Status>

Get can be used to retrieve a chunk. The server may break down the response into a stream of smaller messages, to keep proto messages smaller than its maximum chunk size.

pub async fn put_chunk( &mut self, request: impl IntoStreamingRequest<Message = PutChunkRequest>, ) -> Result<Response<PutChunkResponse>, Status>

PutChunk can be used to upload a chunk. The client may break down the response into a stream of smaller messages, to keep proto messages smaller than its maximum chunk size.

Trait Implementations

impl<T: Clone> Clone for ChunkStoreServiceClient<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ChunkStoreServiceClient<T>

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

Formats the value using the given formatter.