Struct vfs::object_request::ObjectRequest

pub struct ObjectRequest {
    pub truncate: bool,
    /* private fields */
}

Wraps the channel provided in the open methods and provide convenience methods for sending appropriate responses. It also records actions that should be taken upon successful connection such as truncating file objects.

Fields

truncate: bool

Truncate the object before use.

Implementations

impl ObjectRequest

pub fn new3(flags: Flags, options: &Options, object_request: Channel) -> Self

pub fn attributes(&self) -> NodeAttributesQuery

pub fn create_attributes(&self) -> Option<&MutableNodeAttributes>

pub fn options(&self) -> Options

pub async fn into_request_stream<T: Representation>( self, connection: &T, ) -> Result<<T::Protocol as ProtocolMarker>::RequestStream, Status>

Returns the request stream after sending requested information.

pub fn into_server_end<T>(self) -> ServerEnd<T>

Converts to ServerEnd.

pub fn into_channel(self) -> Channel

Extracts the channel (without sending on_open).

pub fn into_channel_after_sending_on_open( self, node_info: NodeInfoDeprecated, ) -> Result<Channel, Status>

Extracts the channel after sending on_open.

pub fn shutdown(self, status: Status)

Terminates the object request with the given status.

pub fn handle<T>( self, f: impl FnOnce(ObjectRequestRef<'_>) -> Result<T, Status>, ) -> Option<T>

Calls f and sends an error on the object request channel upon failure.

pub fn spawn<F, Fut>(self, scope: &ExecutionScope, f: F)

where for<'a> F: FnOnce(ObjectRequestRef<'a>) -> BoxFuture<'a, Result<Fut, Status>> + Send + 'static, Fut: Future<Output = ()> + Send,

Spawn a task for the object request. The callback returns a future that can return a Status which will be handled appropriately. If the future succeeds it should return another future that is responsible for the long term servicing of the object request. This is done to avoid paying the stack cost of the object request for the lifetime of the connection.

For example:

object_request.spawn( scope, move |object_request| Box::pin(async move { // Perform checks on the new connection if !valid(…) { return Err(Status::INVALID_ARGS); } // Upon success, return a future that handles the connection. let requests = object_request.take().into_request_stream(); Ok(async { while let request = requests.next().await { … } }) }));

pub async fn wait_till_ready(&self) -> bool

Waits until the request has a request waiting in its channel. Returns immediately if this request requires sending an initial event such as OnOpen or OnRepresentation. Returns true if the channel is readable (rather than just closed).

pub fn take(&mut self) -> ObjectRequest

Take the ObjectRequest. The caller is responsible for sending errors.

pub fn create_connection<N: Node, F: Future<Output = ()> + Send + 'static, P: ProtocolsExt>( &mut self, scope: ExecutionScope, node: Arc<N>, protocols: P, f: impl FnOnce(ExecutionScope, Arc<N>, P, &mut Self) -> Result<F, Status>, ) -> Result<BoxFuture<'static, ()>, Status>

Returns a future that will run the connection. f is a callback that returns a future that will run the connection but it will not be called if the connection is supposed to be a node connection.

pub fn spawn_connection<N: Node, F: Future<Output = ()> + Send + 'static, P: ProtocolsExt>( &mut self, scope: ExecutionScope, node: Arc<N>, protocols: P, f: impl FnOnce(ExecutionScope, Arc<N>, P, &mut Self) -> Result<F, Status>, ) -> Result<(), Status>

Spawns a new connection for this request. f is similar to create_connection above.

Trait Implementations

impl Debug for ObjectRequest

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

Formats the value using the given formatter.