Struct distant_core::Session

pub struct Session<T> where
    T: DataStream,  {
    pub broadcast: Option<Receiver<Response>>,
    // some fields omitted
}

Represents a session with a remote server that can be used to send requests & receive responses

Fields

broadcast: Option<Receiver<Response>>

Represents the receiver for broadcasted responses (ones with no callback)

Implementations

impl Session<TcpStream>

pub async fn tcp_connect(info: SessionInfo) -> Result<Self>

Connect to a remote TCP server using the provided information

pub async fn tcp_connect_timeout(
    info: SessionInfo,
    duration: Duration
) -> Result<Self>

Connect to a remote TCP server, timing out after duration has passed

impl Session<UnixStream>

pub async fn unix_connect(
    path: impl AsRef<Path>,
    auth_key: Option<Arc<SecretKey>>
) -> Result<Self>

Connect to a proxy unix socket

pub async fn unix_connect_timeout(
    path: impl AsRef<Path>,
    auth_key: Option<Arc<SecretKey>>,
    duration: Duration
) -> Result<Self>

Connect to a proxy unix socket, timing out after duration has passed

impl<T> Session<T> where
    T: DataStream, 

pub fn initialize(transport: Transport<T>) -> Result<Self>

Initializes a session using the provided transport

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

Waits for the session to terminate, which results when the receiving end of the network connection is closed (or the session is shutdown)

pub fn abort(&self)

Abort the session’s current connection by forcing its response task to shutdown

pub async fn send(&mut self, req: Request) -> Result<Response, TransportError>

Sends a request and waits for a response

pub async fn send_timeout(
    &mut self,
    req: Request,
    duration: Duration
) -> Result<Response, TransportError>

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

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

Sends a request without waiting for a response

Any response that would be received gets sent over the broadcast channel instead

pub async fn fire_timeout(
    &mut self,
    req: Request,
    duration: Duration
) -> Result<(), TransportError>

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