Struct BlobWriterSynchronousProxy

pub struct BlobWriterSynchronousProxy { /* private fields */ }

Implementations

impl BlobWriterSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<BlobWriterEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn get_vmo( &self, size: u64, ___deadline: MonotonicInstant, ) -> Result<BlobWriterGetVmoResult, Error>

Truncates the blob associated with this BlobWriter proxy to length size. Returns a handle to a vmo shared between the server and the client, which is implemented as a ring buffer. As the client writes blob contents into the vmo, it will call BytesReady to signal to the server that some number of bytes have been written.

Ring Buffer Semantics The server sets the size of the vmo passed back to the client. The chunks that the client writes are arbitrarily sized and do not have any alignment guarantees. Any particular write can wrap around the ring buffer. The client can have several outstanding BytesReady requests but the client is responsible for not overwriting a given range in the ring buffer until the BytesReady request corresponding to that range has completed.

pub fn bytes_ready( &self, bytes_written: u64, ___deadline: MonotonicInstant, ) -> Result<BlobWriterBytesReadyResult, Error>

Indicates to the server that an additional bytes_written number of bytes have been written to the shared vmo and are ready to be read off the vmo and written to disk. The blob will be readable when the final BytesReady response is received by the client.

Trait Implementations

impl Debug for BlobWriterSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for BlobWriterSynchronousProxy

type Proxy = BlobWriterProxy

The async proxy for the same protocol.

type Protocol = BlobWriterMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.