Struct distant_net::client::Client

pub struct Client<T, U> { /* private fields */ }

Represents a client that can be used to send requests & receive responses from a server.

Implementations

impl<T, U> Client<T, U>where
    T: Send + Sync + Serialize + 'static,
    U: Send + Sync + DeserializeOwned + 'static,

pub fn into_untyped_client(self) -> UntypedClient

Consumes the client, returning an untyped variant.

pub fn spawn_inmemory(
    transport: FramedTransport<InmemoryTransport>,
    strategy: ReconnectStrategy
) -> Self

Spawns a client using the provided FramedTransport of InmemoryTransport and a specific ReconnectStrategy.

Note

This will NOT perform any handshakes or authentication procedures nor will it replay any missing frames. This is to be used when establishing a Client to be run internally within a program.

impl Client<(), ()>

pub fn build() -> ClientBuilder<(), ()>

Creates a new ClientBuilder.

pub fn tcp<T>(
    connector: impl Into<TcpConnector<T>>
) -> ClientBuilder<(), TcpConnector<T>>

Creates a new ClientBuilder configured to use a TcpConnector.

pub fn unix_socket(
    connector: impl Into<UnixSocketConnector>
) -> ClientBuilder<(), UnixSocketConnector>

Creates a new ClientBuilder configured to use a UnixSocketConnector.

impl<T, U> Client<T, U>

pub fn into_channel(self) -> Channel<T, U>

Convert into underlying channel.

pub fn clone_channel(&self) -> Channel<T, U>

Clones the underlying channel for requests and returns the cloned instance.

pub async fn wait(self) -> Result<()>

Waits for the client to terminate, which resolves when the receiving end of the network connection is closed (or the client is shutdown). Returns whether or not the client exited successfully or due to an error.

pub fn abort(&self)

Abort the client’s current connection by forcing its tasks to abort.

pub fn clone_shutdown(&self) -> Box<dyn Shutdown>

Clones the underlying shutdown signaler for the client. This enables you to wait on the client while still having the option to shut it down from somewhere else.

pub async fn shutdown(&self) -> Result<()>

Signal for the client to shutdown its connection cleanly.

pub fn clone_connection_watcher(&self) -> ConnectionWatcher

Clones the underlying [ConnectionStateWatcher] for the client.

pub fn on_connection_change<F>(&self, f: F) -> JoinHandle<()>where
    F: FnMut(ConnectionState) + Send + 'static,

Spawns a new task that continually monitors for connection changes and invokes the function f whenever a new change is detected.

pub fn is_finished(&self) -> bool

Returns true if client’s underlying event processing has finished/terminated.

impl Client<ManagerRequest, ManagerResponse>

pub async fn launch(
    &mut self,
    destination: impl Into<Destination>,
    options: impl Into<Map>,
    handler: impl AuthHandler + Send
) -> Result<Destination>

Request that the manager launches a new server at the given destination with options being passed for destination-specific details, returning the new destination of the spawned server.

The provided handler will be used for any authentication requirements when connecting to the remote machine to spawn the server.

pub async fn connect(
    &mut self,
    destination: impl Into<Destination>,
    options: impl Into<Map>,
    handler: impl AuthHandler + Send
) -> Result<ConnectionId>

Request that the manager establishes a new connection at the given destination with options being passed for destination-specific details.

The provided handler will be used for any authentication requirements when connecting to the server.

pub async fn open_raw_channel(
    &mut self,
    connection_id: ConnectionId
) -> Result<RawChannel>

Establishes a channel with the server represented by the connection_id, returning a RawChannel acting as the connection.

Note

Multiple calls to open a channel against the same connection will result in establishing a duplicate channel to the same server, so take care when using this method.

pub async fn capabilities(&mut self) -> Result<ManagerCapabilities>

Retrieves a list of supported capabilities

pub async fn info(&mut self, id: ConnectionId) -> Result<ConnectionInfo>

Retrieves information about a specific connection

pub async fn kill(&mut self, id: ConnectionId) -> Result<()>

Kills the specified connection

pub async fn list(&mut self) -> Result<ConnectionList>

Retrieves a list of active connections

Methods from Deref<Target = Channel<T, U>>

pub fn is_closed(&self) -> bool

Returns true if no more requests can be transferred

pub async fn assign_default_mailbox(
    &self,
    buffer: usize
) -> Result<Mailbox<Response<U>>>

Assigns a default mailbox for any response received that does not match another mailbox.

pub async fn remove_default_mailbox(&self) -> Result<()>

Removes the default mailbox used for unmatched responses such that any response without a matching mailbox will be dropped.

pub async fn mail(
    &mut self,
    req: impl Into<Request<T>>
) -> Result<Mailbox<Response<U>>>

Sends a request and returns a mailbox that can receive one or more responses, failing if unable to send a request or if the session’s receiving line to the remote server has already been severed

pub async fn mail_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<Mailbox<Response<U>>>

Sends a request and returns a mailbox, timing out after duration has passed

pub async fn send(&mut self, req: impl Into<Request<T>>) -> Result<Response<U>>

Sends a request and waits for a response, failing if unable to send a request or if the session’s receiving line to the remote server has already been severed

pub async fn send_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<Response<U>>

Sends a request and waits for a response, timing out after duration has passed

pub async fn fire(&mut self, req: impl Into<Request<T>>) -> Result<()>

Sends a request without waiting for a response; this method is able to be used even if the session’s receiving line to the remote server has been severed

pub async fn fire_timeout(
    &mut self,
    req: impl Into<Request<T>>,
    duration: impl Into<Option<Duration>>
) -> Result<()>

Sends a request without waiting for a response, timing out after duration has passed

Trait Implementations

impl<T, U> Debug for Client<T, U>

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

Formats the value using the given formatter.

impl<T, U> Deref for Client<T, U>

type Target = Channel<T, U>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, U> DerefMut for Client<T, U>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, U> From<Client<T, U>> for Channel<T, U>

fn from(client: Client<T, U>) -> Self

Converts to this type from the input type.