use std::path::PathBuf;
use std::time::Duration;
use url::Url;
use crate::error::Wrap;
use crate::{Error, Publisher, Result, Subscriber};
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct ClientConfig {
pub url: Url,
pub insecure: bool,
pub tls_cert: Option<PathBuf>,
pub tls_key: Option<PathBuf>,
}
impl ClientConfig {
pub fn new(url: Url) -> Self {
Self {
url,
insecure: false,
tls_cert: None,
tls_key: None,
}
}
pub fn with_insecure(mut self, insecure: bool) -> Self {
self.insecure = insecure;
self
}
pub fn with_client_cert(mut self, cert: impl Into<PathBuf>, key: impl Into<PathBuf>) -> Self {
self.tls_cert = Some(cert.into());
self.tls_key = Some(key.into());
self
}
pub(crate) fn client(&self) -> Result<moq_tokio::Client> {
let mut connect = moq_tokio::connect::Config::default();
if self.insecure {
connect.tls.insecure = Some(true);
}
connect.tls.cert = self.tls_cert.clone();
connect.tls.key = self.tls_key.clone();
connect.init(Default::default()).connection()
}
}
pub fn connect_both(config: &ClientConfig) -> Result<(Publisher, Subscriber)> {
let publish = moq_tokio::origin::spawn();
let subscribe = moq_tokio::origin::spawn();
let session = Session::new(
config
.client()?
.with_publisher(&publish)
.with_subscriber(subscribe.clone())
.connect(config.url.clone()),
);
Ok((
Publisher::from_parts(publish, session.clone()),
Subscriber::from_parts(subscribe, session),
))
}
const REFUSAL_WINDOW: Duration = Duration::from_millis(500);
#[derive(Clone)]
pub struct Session {
connection: moq_tokio::Connection,
}
impl Session {
pub(crate) fn new(connection: moq_tokio::Connection) -> Self {
Self { connection }
}
pub async fn established(&self) -> Result<()> {
let _ = self.connection.clone().established().await.connection()?;
tokio::select! {
res = self.connection.closed() => {
res.connection()?;
Err(Error::Connection("the connection closed right after it was established".into()))
}
_ = tokio::time::sleep(REFUSAL_WINDOW) => Ok(()),
}
}
pub async fn closed(&self) -> Result<()> {
self.connection.closed().await.connection()
}
pub async fn close(&self) -> Result<()> {
self.connection.clone().close().await.connection()
}
}
pub fn broadcast_name_for_topic(topic: &str) -> String {
normalize_broadcast_name(topic).to_string()
}
pub fn normalize_broadcast_name(name: &str) -> &str {
name.trim_matches('/')
}
pub fn broadcast_is_under(name: &str, prefix: &str) -> bool {
let (name, prefix) = (normalize_broadcast_name(name), normalize_broadcast_name(prefix));
prefix.is_empty() || name == prefix || name.strip_prefix(prefix).is_some_and(|rest| rest.starts_with('/'))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn topic_to_broadcast_name() {
assert_eq!(broadcast_name_for_topic("/camera/image_raw"), "camera/image_raw");
assert_eq!(broadcast_name_for_topic("image"), "image");
}
#[test]
fn broadcast_name_trims_all_outer_slashes() {
assert_eq!(broadcast_name_for_topic("/front/image_raw/"), "front/image_raw");
assert_eq!(broadcast_name_for_topic("//image"), "image");
assert_eq!(broadcast_name_for_topic("/"), "");
}
#[test]
fn matches_prefixes_by_segment() {
assert!(broadcast_is_under("robots/a/camera", "robots"));
assert!(broadcast_is_under("robots/a/camera", "robots/a"));
assert!(broadcast_is_under("robots", "robots"));
assert!(broadcast_is_under("anything", ""));
assert!(broadcast_is_under("/robots/a/", "/robots/"));
assert!(broadcast_is_under("anything", "/"));
assert!(!broadcast_is_under("robots2/camera", "robots"));
assert!(!broadcast_is_under("robot", "robots"));
}
#[test]
fn new_config_verifies_tls() {
let config = ClientConfig::new("https://relay.example/anon".parse().unwrap());
assert!(!config.insecure);
assert_eq!(config.url.path(), "/anon");
}
#[test]
fn client_cert_needs_a_key() {
let mut config = ClientConfig::new("https://relay.example/anon".parse().unwrap());
config.tls_cert = Some("client.pem".into());
assert!(config.client().is_err());
}
}