Struct RelayConnectionHandle 

pub struct RelayConnectionHandle {
    pub relay_id: KeyId,
    pub relay_address: RelayAddress,
    result_receiver: Option<Receiver<Result<()>>>,
    _task_handle: JoinHandle<()>,
}

Handle for a background relay connection attempt

This handle allows you to optionally poll the connection result, but the connection attempt continues in the background regardless of whether you poll it or not. The relay status will be updated via the normal status broadcast channels.

Fields

relay_id: KeyId

The relay ID being connected to

relay_address: RelayAddress

The relay address being connected to

result_receiver: Option<Receiver<Result<()>>>

Optional receiver for the final connection result If you don’t need the result, you can ignore this

_task_handle: JoinHandle<()>

Background task handle - kept to prevent the task from being dropped

Implementations

impl RelayConnectionHandle

pub fn try_result(&mut self) -> Result<Option<Result<()>>>

Poll for the connection result (non-blocking)

Returns:

• Ok(Some(result)) if the connection attempt has completed
• Ok(None) if the connection is still in progress
• Err(_) if there was an error polling (shouldn’t happen normally)

pub async fn await_result(self) -> Result<()>

Wait for the connection result (blocking)

This consumes the handle and waits for the background task to complete. If you don’t call this, the connection will still complete in the background.

pub fn detach(self)

Detach from the result, allowing the connection to complete purely in the background

After calling this, you can only track the connection status via the relay status broadcast channels. The connection attempt will continue regardless.

Trait Implementations

impl Debug for RelayConnectionHandle

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

Formats the value using the given formatter.