Enum SignalingMethod 

pub enum SignalingMethod {
    Http(HttpSignalingInfo),
    Https(HttpSignalingInfo),
    HttpsProxy(u16, HttpSignalingInfo),
    P2p {
        relay_peer_id: PeerId,
    },
}

WebRTC signaling transport method configuration.

SignalingMethod defines how WebRTC signaling messages (offers and answers) are transported between peers. Different methods provide flexibility for various network environments and infrastructure requirements.

Method Types

• HTTP/HTTPS: Direct connections to signaling servers
• HTTPS Proxy: Connections through SSL gateway/proxy servers
• P2P Relay: Signaling through existing peer connections

Each method encapsulates the necessary connection information to establish the signaling channel, which is used before the actual WebRTC peer-to-peer connection is established.

Usage

Signaling methods can be parsed from string representations or constructed programmatically. They support serialization for storage and network transmission.

Example

// Direct HTTPS signaling
let method = "/https/signal.example.com/443".parse::<SignalingMethod>()?;

// P2P relay through an existing peer
let method = SignalingMethod::P2p { relay_peer_id: peer_id };

Variants

Http(HttpSignalingInfo)

HTTP signaling server connection.

Uses plain HTTP for signaling message exchange. Typically used for local development or testing environments where encryption is not required.

Https(HttpSignalingInfo)

HTTPS signaling server connection.

Uses secure HTTPS for signaling message exchange. Recommended for production environments to protect signaling data in transit.

HttpsProxy(u16, HttpSignalingInfo)

HTTPS proxy signaling connection.

Uses an SSL gateway/proxy server to reach the actual signaling server. The first parameter is the cluster ID for routing, and the second parameter contains the proxy server connection information.

P2p

P2P relay signaling through an existing peer connection.

Uses an already-established peer connection to relay signaling messages to other peers. This enables signaling when direct access to signaling servers is unavailable and provides redundancy in the signaling process.

Fields

relay_peer_id: PeerId

The peer ID of the relay peer that will forward signaling messages.

Implementations

impl SignalingMethod

pub fn can_connect_directly(&self) -> bool

Determines if this signaling method supports direct connections.

Direct connection methods (HTTP, HTTPS, HTTPS Proxy) can establish signaling channels immediately without requiring existing peer connections. P2P relay methods require an already-established peer connection to function.

Returns

• true for HTTP, HTTPS, and HTTPS Proxy methods
• false for P2P relay methods

This is useful for connection strategy decisions and determining whether bootstrap connections are needed before signaling can occur.

pub fn http_url(&self) -> Option<String>

Constructs the HTTP(S) URL for sending WebRTC offers.

This method generates the appropriate URL endpoint for sending WebRTC signaling messages based on the signaling method configuration.

URL Formats

• HTTP: http://{host}:{port}/mina/webrtc/signal
• HTTPS: https://{host}:{port}/mina/webrtc/signal
• HTTPS Proxy: https://{host}:{port}/clusters/{cluster_id}/mina/webrtc/signal

Returns

• Some(String) containing the signaling URL for HTTP-based methods
• None for P2P relay methods that don’t use HTTP endpoints

Example

let method = SignalingMethod::Https(info);
let url = method.http_url(); // Some("https://signal.example.com:443/mina/webrtc/signal")

pub fn p2p_relay_peer_id(&self) -> Option<PeerId>

Extracts the relay peer ID for P2P signaling methods.

For P2P relay signaling methods, this returns the peer ID of the intermediate peer that will forward signaling messages. This is used to identify which existing peer connection should be used for relaying.

Returns

• Some(PeerId) for P2P relay methods
• None for direct connection methods (HTTP/HTTPS)

Usage

This method is typically used when setting up message routing for P2P relay signaling to determine which peer connection should handle the signaling traffic.

Trait Implementations

impl BinProtRead for SignalingMethod

fn binprot_read<__BinProtR>( __binprot_r: &mut __BinProtR, ) -> Result<SignalingMethod, Error>

where __BinProtR: Read + ?Sized,

impl BinProtWrite for SignalingMethod

fn binprot_write<__BinProtW>( &self, __binprot_w: &mut __BinProtW, ) -> Result<(), Error>

where __BinProtW: Write,

impl Clone for SignalingMethod

fn clone(&self) -> SignalingMethod

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignalingMethod

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignalingMethod

fn deserialize<D>( deserializer: D, ) -> Result<SignalingMethod, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserializes a signaling method from a string.

This uses the FromStr implementation to parse the string representation back into a SignalingMethod instance.

Errors

Returns a deserialization error if the string cannot be parsed as a valid signaling method.

impl Display for SignalingMethod

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

Formats the signaling method as a URL path string.

This implementation converts the signaling method into its string representation following the URL format patterns. The formatted string can be parsed back using FromStr.

Format Patterns

• HTTP: /http/{host}/{port}
• HTTPS: /https/{host}/{port}
• HTTPS Proxy: /https_proxy/{cluster_id}/{host}/{port}
• P2P Relay: /p2p/{peer_id}

impl FromStr for SignalingMethod

fn from_str( s: &str, ) -> Result<SignalingMethod, <SignalingMethod as FromStr>::Err>

Parses a string representation into a SignalingMethod.

This method parses URL-like strings that represent different signaling transport methods. The parser supports the following formats:

Supported Formats

• HTTP: /http/{host}/{port}
• HTTPS: /https/{host}/{port}
• HTTPS Proxy: /https_proxy/{cluster_id}/{host}/{port}
• P2P Relay: /p2p/{peer_id}

Examples

use openmina::signaling_method::SignalingMethod;

// HTTP signaling
let method: SignalingMethod = "/http/localhost/8080".parse()?;

// HTTPS signaling
let method: SignalingMethod = "/https/signal.example.com/443".parse()?;

// HTTPS proxy with cluster ID
let method: SignalingMethod = "/https_proxy/123/proxy.example.com/443".parse()?;

Errors

Returns SignalingMethodParseError for various parsing failures:

• Missing components (host, port, etc.)
• Unknown method types
• Invalid numeric values (ports, cluster IDs)
• Invalid host formats

type Err = SignalingMethodParseError

The associated error which can be returned from parsing.

impl Ord for SignalingMethod

fn cmp(&self, other: &SignalingMethod) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SignalingMethod

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

fn partial_cmp(&self, other: &SignalingMethod) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SignalingMethod

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serializes the signaling method as a string.

This uses the Display implementation to convert the signaling method to its string representation for serialization.

impl Eq for SignalingMethod

impl StructuralPartialEq for SignalingMethod