Struct Target 

pub struct Target {
    pub addr: SocketAddr,
    pub transport: TransportKind,
    pub verify_as: Option<Arc<str>>,
    pub path: Option<Arc<str>>,
}

A destination.

Not Copy, because of verify_as. That field is the reason this type exists rather than a bare (SocketAddr, TransportKind): the address says where to send, while the original URI host says which TLS identity to verify and which HTTP authority a WebSocket handshake must name. Deriving either from the resolved address loses authority information before the connection.

Fields

addr: SocketAddr

Where to send.

transport: TransportKind

How to send.

verify_as: Option<Arc<str>>

Original URI host before resolution: TLS/WSS verification name and WS/WSS HTTP authority. For clear WS it is authority only; no certificate verification is implied.

path: Option<Arc<str>>

The resource the WebSocket handshake asks for. None means /, and None outside WebSocket, where there is no handshake to ask anything of.

Implementations

impl Target

pub fn new(addr: SocketAddr, transport: TransportKind) -> Self

A destination.

pub fn udp(addr: SocketAddr) -> Self

A UDP destination.

pub fn verifying(self, name: impl AsRef<str>) -> Self

The same destination, with its pre-resolution URI host.

TLS/WSS verify certificates against it. WS/WSS also put it in the HTTP Host authority; clear WS uses that authority without implying authentication.

pub fn at_path(self, path: impl AsRef<str>) -> Self

The same destination, with the resource its WebSocket handshake asks for.

RFC 7118 §5 registers a subprotocol and a set of framing rules; it says nothing at all about where on a server SIP lives. A server is therefore entitled to serve it from /, from /ws, or from its own HTTP server on another port, and a client that can only ask for / reaches the first kind and none of the others.

A leading / is supplied when it is missing, because a resource name that lacks one is not a relative path in a request-target — it runs into the authority and silently sends the upgrade somewhere nobody meant. Anything after the path is kept as given: a server that wants a query string gets the one it was handed.

pub fn connection(&self) -> ConnectionKey

Which pooled connection carries traffic for this destination.

Trait Implementations

impl Clone for Target

fn clone(&self) -> Target

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Target

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

Formats the value using the given formatter.

impl Hash for Target

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 PartialEq for Target

fn eq(&self, other: &Target) -> 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 Eq for Target

impl StructuralPartialEq for Target