Struct tvix_castore::proto::blob_service_client::BlobServiceClient

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

BlobService allows reading (or uploading) content-addressed blobs of 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.

Fields

inner: Grpc<T>

Implementations

impl BlobServiceClient<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> BlobServiceClient<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 ) -> BlobServiceClient<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 stat( &mut self, request: impl IntoRequest<StatBlobRequest> ) -> Result<Response<StatBlobResponse>, Status>

Stat can be used to check for the existence of a blob, as well as gathering more data about it, like more granular chunking information or baos. Server implementations are not required to provide more granular chunking information, especially if the digest specified in StatBlobRequest is already a chunk of a blob.

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

Read allows reading (all) data of a blob/chunk by the BLAKE3 digest of its contents. If the backend communicated more granular chunks in the Stat request, this can also be used to read chunks. This request returns a stream of BlobChunk, which is just a container for a stream of bytes. The server may decide on whatever chunking it may seem fit as a size for the individual BlobChunk sent in the response stream, this is mostly to keep individual messages at a manageable size.

pub async fn put( &mut self, request: impl IntoStreamingRequest<Message = BlobChunk> ) -> Result<Response<PutBlobResponse>, Status>

Put uploads a Blob, by reading a stream of bytes.

The way the data is chunked up in individual BlobChunk messages sent in the stream has no effect on how the server ends up chunking blobs up, if it does at all.

Trait Implementations

impl<T: Clone> Clone for BlobServiceClient<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BlobServiceClient<T>

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

Formats the value using the given formatter.