Struct Client 

pub struct Client { /* private fields */ }

Session against one deployed relay.

The credential is per-client, not process-global. Two clients in the same process may use different keys.

Implementations

impl Client

pub fn new(config: ClientConfig) -> Result<Client, Error>

pub fn from_credential( server: impl Into<String>, credential: Credential, keep_alive: bool, namespace: Option<u64>, ) -> Client

Build a client from an already-parsed credential.

pub fn with_relay_transport( &self, transport: RelayTransport, ) -> Result<Client, Error>

Select the relay carrier for subsequent work. Existing handles retain their carrier. TCP remains the default. QUIC requires the relay-quic feature and a QUIC-enabled relay.

pub fn relay_transport(&self) -> RelayTransport

pub async fn relay_diagnostics(&self) -> RelayDiagnostics

Sample current QUIC counters without a background observer or per-packet work. Clients of the same relay and carrier in this process share one pool.

pub async fn relay_quic_port(&self) -> Result<Option<u16>, Error>

The UDP port the relay offers QUIC on, or None when it offers none: one started without a QUIC listener, or one from before QUIC. Asked over TCP whatever this client’s carrier, so a TCP client can learn whether QUIC would work before switching to it.

pub fn notify_network_change(&self)

Notify workers after a host network/resume event. This does not mark services healthy.

pub fn server(&self) -> &str

pub fn namespace(&self) -> Option<u64>

pub fn admin(&self) -> Result<Admin, Error>

Administrator RPCs. Fails locally when the session is not an admin key.

pub async fn register( &self, request: RegisterRequest, ) -> Result<Registration, Error>

Publish a local service on the relay under request.key, with RegisterOptions::default: direct sessions are allowed when the SDK is built with p2p.

Returns as soon as the worker is spawned; the handle’s Registration::wait_ready is what waits for the relay to accept it.

pub async fn register_with_idle_timeout( &self, request: RegisterRequest, idle_timeout: Duration, ) -> Result<Registration, Error>

Publish with an idle deadline for each forwarded TCP data connection.

Traffic in either direction resets the deadline; control connections and other registrations are unaffected. Zero disables the idle deadline. UDP requests are rejected because datagram lifetime has a separate policy. Durations that cannot be represented as a timer deadline are rejected.

pub async fn register_with_options( &self, request: RegisterRequest, options: RegisterOptions, ) -> Result<Registration, Error>

Publish a service with explicit options, such as allow_direct: false to keep every session on the relay.

pub async fn connect( &self, request: ConnectRequest, ) -> Result<Connection, Error>

Subscribe to a registered service and forward it from a local listener, with ConnectOptions::default: direct first with relay fallback when the SDK is built with p2p.

Returns as soon as the worker is spawned; the handle’s Connection::wait_ready is what waits for the local listener to bind and the relay to confirm the service.

pub async fn connect_with_options( &self, request: ConnectRequest, options: ConnectOptions, ) -> Result<Connection, Error>

Select direct-first or the relay-only protocol for this tunnel only.

pub async fn list_keys(&self) -> Result<Vec<String>, Error>

Service keys visible to this credential’s namespace.

pub async fn sessions(&self) -> Result<Vec<SessionObservation>, Error>

Endpoint observations; stale or conflicting reports do not control sessions.

pub async fn service_status( &self, key: impl Into<String>, ) -> Result<Vec<ServiceConnection>, Error>

pub async fn remote_id(&self) -> Result<RemoteId, Error>

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.