Struct ReqSocket 

pub struct ReqSocket<T: Transport<A>, A: Address> { /* private fields */ }

The request socket.

Implementations

impl<T> ReqSocket<T, SocketAddr>

where T: Transport<SocketAddr>,

pub async fn connect( &mut self, addr: impl ToSocketAddrs, ) -> Result<(), ReqError>

Connects to the target address with the default options.

pub fn connect_sync(&mut self, addr: SocketAddr)

Starts connecting to a resolved socket address. This is essentially a Self::connect variant that doesn’t error or block due to DNS resolution and blocking connect.

impl<T> ReqSocket<T, PathBuf>

where T: Transport<PathBuf>,

pub async fn connect( &mut self, addr: impl Into<PathBuf>, ) -> Result<(), ReqError>

Connects to the target path with the default options.

impl<T, A> ReqSocket<T, A>

where T: Transport<A>, A: Address,

pub fn new(transport: T) -> Self

pub fn with_options(transport: T, options: ReqOptions) -> Self

pub fn with_compressor<C: Compressor + 'static>(self, compressor: C) -> Self

Sets the message compressor for this socket.

pub fn with_connection_hook<H>(self, hook: H) -> Self

where H: ConnectionHook<T::Io>,

Sets the connection hook for this socket.

The connection hook is called after connecting to the server, before the connection is used for request/reply communication.

Panics

Panics if the driver has already been started (i.e., after calling connect).

pub fn stats(&self) -> &SocketStats<ReqStats>

Returns the socket stats.

pub fn transport_stats(&self) -> Guard<Arc<T::Stats>>

Get the latest transport-level stats snapshot.

pub async fn request(&self, message: Bytes) -> Result<Bytes, ReqError>

pub async fn try_connect(&mut self, endpoint: A) -> Result<(), ReqError>

Tries to connect to the target endpoint with the default options. A ReqSocket can only be connected to a single address.