use super::{
EventOptions, HandshakeDiagnosticOptions, HandshakeProvider, ReceiveOptions, ReceiveOverflow,
ReconnectPolicy, ResponseRouting,
};
use crate::{HeaderMap, Metadata, NetError, Result};
use std::time::Duration;
#[derive(Clone)]
pub struct ConnectOptions {
pub url: String,
pub headers: HeaderMap,
pub handshake_provider: Option<HandshakeProvider>,
pub metadata: Metadata,
pub reconnect: ReconnectPolicy,
pub handshake_timeout: Duration,
pub connect_timeout: Option<Duration>,
pub initial_messages: InitialMessages,
pub event_history: EventOptions,
pub routing: ResponseRouting,
pub diagnostics: Option<HandshakeDiagnosticOptions>,
}
impl ConnectOptions {
pub fn new(url: impl Into<String>) -> Self {
Self {
url: url.into(),
headers: HeaderMap::new(),
handshake_provider: None,
metadata: Metadata::new(),
reconnect: ReconnectPolicy::default(),
handshake_timeout: Duration::from_secs(10),
connect_timeout: Some(Duration::from_secs(30)),
initial_messages: InitialMessages::default(),
event_history: EventOptions::default(),
routing: ResponseRouting::default(),
diagnostics: None,
}
}
pub fn validate(&self) -> Result<()> {
let uri = self
.url
.parse::<http::Uri>()
.map_err(|_| NetError::config("url", "must be a valid WebSocket URL"))?;
if !matches!(uri.scheme_str(), Some("ws" | "wss")) || uri.host().is_none() {
return Err(NetError::config("url", "must use ws or wss with a host"));
}
super::validate_headers(&self.headers)?;
super::validate_metadata(&self.metadata)?;
self.reconnect.validate()?;
super::config::deadline(self.handshake_timeout, "handshake_timeout", false)?;
if let Some(timeout) = self.connect_timeout {
super::config::deadline(timeout, "connect_timeout", false)?;
}
self.event_history.validate()?;
if let InitialMessages::Buffer(options) = &self.initial_messages {
options.validate()?;
if matches!(self.routing, ResponseRouting::Manual)
&& options.overflow == ReceiveOverflow::DropOldest
{
return Err(NetError::config(
"initial_messages.overflow",
"Manual routing requires a lossless initial inbox",
));
}
}
if let Some(options) = &self.diagnostics {
options.validate()?;
}
Ok(())
}
}
impl From<String> for ConnectOptions {
fn from(url: String) -> Self {
Self::new(url)
}
}
impl From<&str> for ConnectOptions {
fn from(url: &str) -> Self {
Self::new(url)
}
}
impl std::fmt::Debug for ConnectOptions {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ConnectOptions")
.field("url", &"[redacted]")
.field("header_count", &self.headers.len())
.field("has_handshake_provider", &self.handshake_provider.is_some())
.field("metadata_entries", &self.metadata.len())
.field("reconnect", &self.reconnect)
.field("handshake_timeout", &self.handshake_timeout)
.field("connect_timeout", &self.connect_timeout)
.field("initial_messages", &self.initial_messages)
.field("event_history", &self.event_history)
.field("routing", &self.routing)
.field("diagnostics", &self.diagnostics)
.finish()
}
}
#[derive(Clone, Debug)]
pub enum InitialMessages {
Buffer(
ReceiveOptions,
),
DiscardUnmatched,
}
impl Default for InitialMessages {
fn default() -> Self {
Self::Buffer(ReceiveOptions::default())
}
}