Struct Connect 

pub(crate) struct Connect<R: Addresses> {
    pub(crate) socket: ConnectAddress<R>,
    pub(crate) socket_canonical: Option<AddrWithStr<R::SocketAddr>>,
    pub(crate) auth: Auth<R>,
    pub(crate) socket_address_file: Option<R::Path>,
    pub(crate) superuser: bool,
}

Information for a connect point that is implemented by making a socket connection to an address.

Fields

socket: ConnectAddress<R>

The address of the socket at which the client should try to reach the RPC server, and which the RPC server should bind.

socket_canonical: Option<AddrWithStr<R::SocketAddr>>

The address of the socket which the RPC server believes it is actually listening at.

If absent, defaults to socket.

This value is only needs to be different from socket in cases where cookie authentication is in use, and the client is sandboxed somehow (such as behind a NAT, or inside a container).

auth: Auth<R>

The authentication that the client should try to use, and which the server should require.

socket_address_file: Option<R::Path>

A file in which the actual value of an inet-auto address should be stored.

superuser: bool

If true, we should allow authenticated connections to this connect point to acquire superuser permissions.

Implementations

impl Connect<Resolved>

fn find_connect_address( &self, mistrust: &Mistrust, ) -> Result<AddrWithStr<SocketAddr>, ConnectError>

Return the address that we should actually try to connect to, with its string representation set to the canonical address.

fn do_connect(&self, mistrust: &Mistrust) -> Result<Connection, ConnectError>

Try to connect on a “Connect” connect point.

impl Connect<Unresolved>

fn resolve( &self, resolver: &CfgPathResolver, ) -> Result<Connect<Resolved>, ResolveError>

Expand all variables within this Connect to their concrete forms.

impl Connect<Resolved>

fn validate(self) -> Result<Self, ResolveError>

Return this Connect only if its parts are valid and compatible.

fn check_absolute_paths(&self) -> Result<(), ResolveError>

Return an error if some path in this Connect is not absolute.

impl Connect<Resolved>

async fn bind<R>( &self, runtime: &R, mistrust: &Mistrust, ) -> Result<Listener, ConnectError>

where R: NetStreamProvider<SocketAddr, Listener = Listener>,

Try to bind to a “Connect” connect point.

Trait Implementations

impl<R: Clone + Addresses> Clone for Connect<R>

where R::SocketAddr: Clone, R::Path: Clone,

fn clone(&self) -> Connect<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Addresses> Debug for Connect<R>

where R::SocketAddr: Debug, R::Path: Debug,

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

Formats the value using the given formatter.

impl<'de, R: Addresses> Deserialize<'de> for Connect<R>

where R::Path: Deserialize<'de>, AddrWithStr<R::SocketAddr>: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.