Struct HttpSignalingInfo 

pub struct HttpSignalingInfo {
    pub host: Host,
    pub port: u16,
}

HTTP signaling server connection information.

HttpSignalingInfo encapsulates the network location information needed to connect to an HTTP-based WebRTC signaling server. This includes the host address and port number required for establishing HTTP connections.

Usage

This struct is used by both HTTP and HTTPS signaling methods, as well as HTTPS proxy configurations. It provides the fundamental addressing information needed to construct signaling URLs and establish connections.

Fields

• host: The server hostname, IP address, or multiaddr
• port: The TCP port number for the HTTP service

Examples

use openmina::webrtc::Host;
use openmina::signaling_method::HttpSignalingInfo;

// IPv4 signaling server
let info = HttpSignalingInfo {
    host: Host::Ipv4("192.168.1.100".parse()?),
    port: 8080,
};

// Domain-based signaling server
let info = HttpSignalingInfo {
    host: Host::Domain("signal.example.com".into()),
    port: 443,
};

Fields

host: Host

The host address for the HTTP signaling server.

This can be a domain name, IPv4 address, IPv6 address, or multiaddr depending on the network configuration and addressing requirements.

port: u16

The TCP port number for the HTTP signaling server.

Standard ports are 80 for HTTP and 443 for HTTPS, but custom ports can be used depending on the server configuration.

Trait Implementations

impl BinProtRead for HttpSignalingInfo

fn binprot_read<__BinProtR: Read + ?Sized>( __binprot_r: &mut __BinProtR, ) -> Result<Self, Error>

impl BinProtWrite for HttpSignalingInfo

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

impl Clone for HttpSignalingInfo

fn clone(&self) -> HttpSignalingInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HttpSignalingInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HttpSignalingInfo

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserializes HTTP signaling info from a string.

This uses the FromStr implementation to parse the string representation back into an HttpSignalingInfo instance. The expected format is {host}/{port} or /{host}/{port}.

Errors

Returns a deserialization error if the string cannot be parsed as valid HTTP signaling info (invalid host, port, or format).

impl Display for HttpSignalingInfo

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

Formats the HTTP signaling info as a path component string.

This creates a string representation suitable for inclusion in signaling method URLs. The format is /{host}/{port} where the host and port are formatted according to their respective types.

Example Output

• IPv4: /192.168.1.100/8080
• Domain: /signal.example.com/443
• IPv6: /[::1]/8080

impl From<([u8; 4], u16)> for HttpSignalingInfo

fn from(value: ([u8; 4], u16)) -> Self

Creates HTTP signaling info from an IPv4 address and port tuple.

This convenience constructor allows easy creation of HttpSignalingInfo from raw IPv4 address bytes and a port number.

Parameters

• value - A tuple containing (IPv4 address bytes, port number)

Example

let info = HttpSignalingInfo::from(([192, 168, 1, 100], 8080));
assert_eq!(info.port, 8080);

impl FromStr for HttpSignalingInfo

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string representation into HTTP signaling info.

This method parses path-like strings that contain host and port information separated by forward slashes. The expected format is {host}/{port} or /{host}/{port}.

Format

• Input: {host}/{port} (leading slash optional)
• Host: Domain name, IPv4, IPv6, or multiaddr format
• Port: 16-bit unsigned integer (0-65535)

Examples

use openmina::signaling_method::HttpSignalingInfo;

// Domain and port
let info: HttpSignalingInfo = "signal.example.com/443".parse()?;

// IPv4 and port
let info: HttpSignalingInfo = "192.168.1.100/8080".parse()?;

// With leading slash
let info: HttpSignalingInfo = "/localhost/8080".parse()?;

Errors

Returns SignalingMethodParseError for:

• Missing host or port components
• Invalid host format (not a valid hostname, IP, or multiaddr)
• Invalid port number (not a valid 16-bit unsigned integer)

type Err = SignalingMethodParseError

The associated error which can be returned from parsing.

impl Ord for HttpSignalingInfo

fn cmp(&self, other: &HttpSignalingInfo) -> 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 HttpSignalingInfo

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

fn partial_cmp(&self, other: &HttpSignalingInfo) -> 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 HttpSignalingInfo

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

where S: Serializer,

Serializes the HTTP signaling info as a string.

This uses the Display implementation to convert the signaling info to its string representation for serialization. The output format is /{host}/{port}.

impl Eq for HttpSignalingInfo

impl StructuralPartialEq for HttpSignalingInfo