Struct ConnectInfo

pub struct ConnectInfo<R> { /* private fields */ }

Connection request information.

May contain known/pre-resolved socket address(es) or a host that needs resolving with DNS.

Implementations

impl<R: Host> ConnectInfo<R>

pub fn new(request: R) -> ConnectInfo<R>

Constructs new connection info using a request.

pub fn with_addr(request: R, addr: SocketAddr) -> ConnectInfo<R>

Constructs new connection info from request and known socket address.

Since socket address is known, Connector will skip the DNS resolution step.

pub fn set_port(self, port: u16) -> Self

Set connection port.

If request provided a port, this will override it.

pub fn set_addr(self, addr: impl Into<Option<SocketAddr>>) -> Self

Set connection socket address.

pub fn set_addrs<I>(self, addrs: I) -> Self

where I: IntoIterator<Item = SocketAddr>,

Set list of addresses.

pub fn set_local_addr(self, addr: impl Into<IpAddr>) -> Self

Set local address to connection with.

Useful in situations where the IP address bound to a particular network interface is known. This would make sure the socket is opened through that interface.

pub fn request(&self) -> &R

Returns a reference to the connection request.

pub fn hostname(&self) -> &str

Returns request hostname.

pub fn port(&self) -> u16

Returns request port.

pub fn addrs( &self, ) -> impl Iterator<Item = SocketAddr> + ExactSizeIterator + FusedIterator + Clone + Debug + '_

Get borrowed iterator of resolved request addresses.

Examples

let addr = SocketAddr::from(([127, 0, 0, 1], 4242));

let conn = ConnectInfo::new("localhost");
let mut addrs = conn.addrs();
assert!(addrs.next().is_none());

let conn = ConnectInfo::with_addr("localhost", addr);
let mut addrs = conn.addrs();
assert_eq!(addrs.next().unwrap(), addr);

pub fn take_addrs( &mut self, ) -> impl Iterator<Item = SocketAddr> + ExactSizeIterator + FusedIterator + Clone + Debug + 'static

Take owned iterator resolved request addresses.

Examples

let addr = SocketAddr::from(([127, 0, 0, 1], 4242));

let mut conn = ConnectInfo::new("localhost");
let mut addrs = conn.take_addrs();
assert!(addrs.next().is_none());

let mut conn = ConnectInfo::with_addr("localhost", addr);
let mut addrs = conn.take_addrs();
assert_eq!(addrs.next().unwrap(), addr);

Trait Implementations

impl<R: Debug> Debug for ConnectInfo<R>

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

Formats the value using the given formatter.

impl<R: Host> Display for ConnectInfo<R>

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

Formats the value using the given formatter.

impl<R: Host> From<R> for ConnectInfo<R>

fn from(addr: R) -> Self

Converts to this type from the input type.

impl<R: Hash> Hash for ConnectInfo<R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R: PartialEq> PartialEq for ConnectInfo<R>

fn eq(&self, other: &ConnectInfo<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Host> Service<ConnectInfo<R>> for ConnectorService

type Response = Connection<R, TcpStream>

Responses given by the service.

type Error = ConnectError

Errors produced by the service when polling readiness or executing call.

type Future = ConnectServiceResponse<R>

The future response value.

fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Ready when the service is able to process requests.

fn call(&self, req: ConnectInfo<R>) -> Self::Future

Process the request and return the response asynchronously.

impl<R: Host> Service<ConnectInfo<R>> for ResolverService

type Response = ConnectInfo<R>

Responses given by the service.

type Error = ConnectError

Errors produced by the service when polling readiness or executing call.

type Future = ResolverFut<R>

The future response value.

fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Ready when the service is able to process requests.

fn call(&self, req: ConnectInfo<R>) -> Self::Future

Process the request and return the response asynchronously.

impl<R: Host> Service<ConnectInfo<R>> for TcpConnectorService

type Response = Connection<R, TcpStream>

Responses given by the service.

type Error = ConnectError

Errors produced by the service when polling readiness or executing call.

type Future = TcpConnectorFut<R>

The future response value.

fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Ready when the service is able to process requests.

fn call(&self, req: ConnectInfo<R>) -> Self::Future

Process the request and return the response asynchronously.

impl<R: Host> ServiceFactory<ConnectInfo<R>> for Connector

type Response = Connection<R, TcpStream>

Responses given by the created services.

type Error = ConnectError

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ConnectorService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Ready<Result<<Connector as ServiceFactory<ConnectInfo<R>>>::Service, <Connector as ServiceFactory<ConnectInfo<R>>>::InitError>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.

impl<R: Host> ServiceFactory<ConnectInfo<R>> for Resolver

type Response = ConnectInfo<R>

Responses given by the created services.

type Error = ConnectError

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ResolverService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Ready<Result<<Resolver as ServiceFactory<ConnectInfo<R>>>::Service, <Resolver as ServiceFactory<ConnectInfo<R>>>::InitError>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.

impl<R: Host> ServiceFactory<ConnectInfo<R>> for TcpConnector

type Response = Connection<R, TcpStream>

Responses given by the created services.

type Error = ConnectError

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = TcpConnectorService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Ready<Result<<TcpConnector as ServiceFactory<ConnectInfo<R>>>::Service, <TcpConnector as ServiceFactory<ConnectInfo<R>>>::InitError>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.

impl<R: Eq> Eq for ConnectInfo<R>

impl<R> StructuralPartialEq for ConnectInfo<R>