Struct RunningService 

pub struct RunningService<R, S>
where
    R: ServiceRole,
    S: Service<R>,
{ /* private fields */ }

Implementations

impl<R, S> RunningService<R, S>

where R: ServiceRole, S: Service<R>,

pub fn peer(&self) -> &Peer<R>

pub fn service(&self) -> &S

pub fn cancellation_token(&self) -> RunningServiceCancellationToken

pub fn is_closed(&self) -> bool

Returns true if the service has been closed or cancelled.

pub async fn waiting(self) -> Result<QuitReason, JoinError>

Wait for the service to complete.

This will block until the service loop terminates (either due to cancellation, transport closure, or an error).

pub async fn close(&mut self) -> Result<QuitReason, JoinError>

Gracefully close the connection and wait for cleanup to complete.

This method cancels the service, waits for the background task to finish (which includes calling transport.close()), and ensures all cleanup operations complete before returning.

Unlike cancel, this method takes &mut self and can be called without consuming the RunningService. After calling this method, the service is considered closed and subsequent operations will fail.

Example

let mut client = ().serve(transport).await?;
// ... use the client ...
client.close().await?;

pub async fn close_with_timeout( &mut self, timeout: Duration, ) -> Result<Option<QuitReason>, JoinError>

Gracefully close the connection with a timeout.

Similar to close, but returns after the specified timeout if the cleanup doesn’t complete in time. This is useful for ensuring a bounded shutdown time.

Returns Ok(Some(reason)) if shutdown completed within the timeout, Ok(None) if the timeout was reached, or Err if there was a join error.

pub async fn cancel(self) -> Result<QuitReason, JoinError>

Cancel the service and wait for cleanup to complete.

This consumes the RunningService and ensures the connection is properly closed. For a non-consuming alternative, see close.

Methods from Deref<Target = Peer<R>>

pub async fn send_notification( &self, notification: <R as ServiceRole>::Not, ) -> Result<(), ServiceError>

pub async fn send_request( &self, request: <R as ServiceRole>::Req, ) -> Result<<R as ServiceRole>::PeerResp, ServiceError>

pub async fn send_cancellable_request( &self, request: <R as ServiceRole>::Req, options: PeerRequestOptions, ) -> Result<RequestHandle<R>, ServiceError>

pub async fn send_request_with_option( &self, request: <R as ServiceRole>::Req, options: PeerRequestOptions, ) -> Result<RequestHandle<R>, ServiceError>

pub fn peer_info(&self) -> Option<&<R as ServiceRole>::PeerInfo>

pub fn set_peer_info(&self, info: <R as ServiceRole>::PeerInfo)

pub fn is_transport_closed(&self) -> bool

Trait Implementations

impl<R, S> Debug for RunningService<R, S>

where R: Debug + ServiceRole, S: Debug + Service<R>,

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

Formats the value using the given formatter.

impl<R, S> Deref for RunningService<R, S>

where R: ServiceRole, S: Service<R>,

type Target = Peer<R>

The resulting type after dereferencing.

fn deref(&self) -> &<RunningService<R, S> as Deref>::Target

Dereferences the value.

impl<R, S> Drop for RunningService<R, S>

where R: ServiceRole, S: Service<R>,

fn drop(&mut self)

Executes the destructor for this type.