feat: iroh support

dev/relay.toml

@@ -25,3 +25,11 @@ listen = "[::]:4443"
 [auth]
 # Allow anonymous access to everything.
 public = ""
+
+[iroh]
+# 32 byte secret key for the iroh endpoint. Defines the endpoint ID of the iroh endpoint.
+# The matching endpoint id is set in the justfile as a default for the `pub-iroh` command.
+# Can also be set via MOQ_IROH_SECRET env variable if you don't want to put secrets into the config file.
+# Alternatively, set `secret_key_path` to a path to load the secret key from a file.
+# If the file does not exist, a random key will be generated and written to the path.
+secret_key = "b724c6a37a004ae3d14c3efed84ccc145ee78f884e40f1b47063bdfd479ebed1"

justfile

@@ -128,23 +128,31 @@ download-url name:
 		*) echo "unknown" && exit 1 ;; \
 	esac
 
+# Convert an h264 input file to CMAF (fmp4) format to stdout.
+ffmpeg-cmaf input output='-' *args:
+	ffmpeg -hide_banner -v quiet \
+		-stream_loop -1 -re \
+		-i "{{input}}" \
+		-c copy \
+		-f mp4 -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame {{args}} {{output}}
+
 # Publish a video using ffmpeg to the localhost relay server
 # NOTE: The `http` means that we perform insecure certificate verification.
 # Switch it to `https` when you're ready to use a real certificate.
-pub name url="http://localhost:4443/anon" *args:
+pub name='bbb' url="http://localhost:4443/anon" *args:
 	# Download the sample media.
 	just download "{{name}}"
-
 	# Pre-build the binary so we don't queue media while compiling.
 	cargo build --bin hang
+	# Publish the media with the hang cli.
+	just ffmpeg-cmaf "dev/{{name}}.fmp4" | cargo run --bin hang -- publish --url "{{url}}" --name "{{name}}" fmp4 {{args}}
 
-	# Run ffmpeg and pipe the output to hang
-	ffmpeg -hide_banner -v quiet \
-		-stream_loop -1 -re \
-		-i "dev/{{name}}.fmp4" \
-		-c copy \
-		-f mp4 -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
-		- | cargo run --bin hang -- publish --url "{{url}}" --name "{{name}}" fmp4 {{args}}
+# Publish a video file using ffmpeg to a relay server over iroh
+# NOTE: The default url (iroh endpoint id) matches the secret key set in dev/relay.toml
+pub-iroh name='bbb' url='iroh://a73123fce41108f024a196a399edadbba8060be166c779aa50bf4731931492d3' *args:
+	cargo build --bin hang
+	# Publish the media with the hang cli.
+	just ffmpeg-cmaf "dev/{{name}}.fmp4" | cargo run --bin hang -- publish --url "{{url}}" --name "anon/{{name}}" fmp4 {{args}}
 
 # Generate and ingest an HLS stream from a video file.
 pub-hls name relay="http://localhost:4443/anon":
@@ -235,20 +243,27 @@ sub name url='http://localhost:4443/anon':
 	@echo "Install and use hang-gst directly for GStreamer functionality"
 
 # Publish a video using ffmpeg directly from hang to the localhost
-serve name:
+serve name="bbb":
 	# Download the sample media.
 	just download "{{name}}"
 
 	# Pre-build the binary so we don't queue media while compiling.
 	cargo build --bin hang
 
 	# Run ffmpeg and pipe the output to hang
-	ffmpeg -hide_banner -v quiet \
-		-stream_loop -1 -re \
-		-i "dev/{{name}}.fmp4" \
-		-c copy \
-		-f mp4 -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
-		- | cargo run --bin hang -- serve --listen "[::]:4443" --tls-generate "localhost" --name "{{name}}"
+	just ffmpeg-cmaf "dev/{{name}}.fmp4" | \
+		cargo run --bin hang -- serve --listen "[::]:4443" --tls-generate "localhost" --name "{{name}}" fmp4
+
+serve-iroh name="bbb":
+	# Download the sample media.
+	just download "{{name}}"
+
+	# Pre-build the binary so we don't queue media while compiling.
+	cargo build --bin hang
+
+	# Run ffmpeg and pipe the output to hang
+	just ffmpeg-cmaf "dev/{{name}}.fmp4" | \
+		cargo run --bin hang -- serve --iroh --listen "[::]:4443" --tls-generate "localhost" --name "{{name}}" fmp4 \
 
 # Run the web server
 web url='http://localhost:4443/anon':

rs/hang-cli/Cargo.toml

@@ -29,3 +29,7 @@ tokio = { workspace = true, features = ["full"] }
 tower-http = { version = "0.6", features = ["cors", "fs"] }
 tracing = "0.1"
 url = "2"
+
+[features]
+default = ["iroh"]
+iroh = ["moq-native/iroh"]

rs/hang-cli/src/client.rs

@@ -1,14 +1,38 @@
 use crate::Publish;
 
 use hang::moq_lite;
+use moq_native::web_transport_quinn::generic;
 use url::Url;
 
-pub async fn client(config: moq_native::ClientConfig, url: Url, name: String, publish: Publish) -> anyhow::Result<()> {
-	let client = config.init()?;
-
+pub async fn client(
+	config: moq_native::ClientConfig,
+	#[cfg(feature = "iroh")] iroh: moq_native::iroh::EndpointConfig,
+	url: Url,
+	name: String,
+	publish: Publish,
+) -> anyhow::Result<()> {
 	tracing::info!(%url, %name, "connecting");
-	let session = client.connect(url).await?;
+	match url.scheme() {
+		#[cfg(feature = "iroh")]
+		"iroh" => {
+			let client = iroh.init_client().await?;
+			let session = client.connect(url).await?;
+			run_import_session(session, name, publish).await?;
+			client.close().await;
+			Ok(())
+		}
+		_ => {
+			let client = config.init()?;
+			let session = client.connect(url).await?;
+			run_import_session(session, name, publish).await
+		}
+	}
+}
 
+async fn run_import_session<S>(session: S, name: String, publish: Publish) -> anyhow::Result<()>
+where
+	S: generic::Session,
+{
 	// Create an origin producer to publish to the broadcast.
 	let origin = moq_lite::Origin::produce();
 	origin.producer.publish_broadcast(&name, publish.consume());

rs/hang-cli/src/main.rs

@@ -25,6 +25,16 @@ pub enum Command {
 		#[command(flatten)]
 		config: moq_native::ServerConfig,
 
+		/// Optionally enable serving via iroh.
+		#[cfg(feature = "iroh")]
+		#[clap(long)]
+		iroh: bool,
+
+		/// Configuration for the iroh endpoint.
+		#[cfg(feature = "iroh")]
+		#[command(flatten)]
+		iroh_config: moq_native::iroh::EndpointConfig,
+
 		/// The name of the broadcast to serve.
 		#[arg(long)]
 		name: String,
@@ -42,6 +52,13 @@ pub enum Command {
 		#[command(flatten)]
 		config: moq_native::ClientConfig,
 
+		/// Configuration for the iroh endpoint.
+		///
+		/// It will be used for URLs with the iroh:// scheme.
+		#[cfg(feature = "iroh")]
+		#[command(flatten)]
+		iroh_config: moq_native::iroh::EndpointConfig,
+
 		/// The URL of the MoQ server.
 		///
 		/// The URL must start with `https://` or `http://`.
@@ -79,7 +96,43 @@ async fn main() -> anyhow::Result<()> {
 	publish.init().await?;
 
 	match cli.command {
-		Command::Serve { config, dir, name, .. } => server(config, name, dir, publish).await,
-		Command::Publish { config, url, name, .. } => client(config, url, name, publish).await,
+		Command::Serve {
+			config,
+			dir,
+			name,
+			#[cfg(feature = "iroh")]
+			iroh,
+			#[cfg(feature = "iroh")]
+			iroh_config,
+			..
+		} => {
+			server(
+				config,
+				#[cfg(feature = "iroh")]
+				iroh.then_some(iroh_config),
+				name,
+				dir,
+				publish,
+			)
+			.await
+		}
+		Command::Publish {
+			config,
+			#[cfg(feature = "iroh")]
+			iroh_config,
+			url,
+			name,
+			..
+		} => {
+			client(
+				config,
+				#[cfg(feature = "iroh")]
+				iroh_config,
+				url,
+				name,
+				publish,
+			)
+			.await
+		}
 	}
 }

rs/hang-cli/src/server.rs

@@ -4,15 +4,21 @@ use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::{http::Method, routing::get, Router};
 use hang::moq_lite;
+#[cfg(feature = "iroh")]
+use moq_native::iroh::EndpointConfig;
+use moq_native::web_transport_quinn::generic::Session;
+use std::future::Future;
 use std::net::SocketAddr;
 use std::path::PathBuf;
+use std::pin::Pin;
 use tower_http::cors::{Any, CorsLayer};
 use tower_http::services::ServeDir;
 
 use crate::Publish;
 
 pub async fn server(
 	config: moq_native::ServerConfig,
+	#[cfg(feature = "iroh")] iroh_config: Option<EndpointConfig>,
 	name: String,
 	public: Option<PathBuf>,
 	publish: Publish,
@@ -25,6 +31,22 @@ pub async fn server(
 		.context("invalid listen address")?;
 
 	let server = config.init()?;
+	tracing::info!(addr = ?server.local_addr(), "listening");
+
+	// Init iroh server if enabled.
+	#[cfg(feature = "iroh")]
+	let iroh_fut = if let Some(iroh_config) = iroh_config {
+		let server = iroh_config.init_server().await?;
+		tracing::info!(endpoint_id = %server.endpoint().id(), "iroh listening");
+		Box::pin(accept(server, name.clone(), publish.consume())) as Pin<Box<dyn Future<Output = _>>>
+	} else {
+		Box::pin(std::future::pending::<anyhow::Result<()>>())
+	};
+
+	// tokio::select! does not support feature flags on match arms, thus we set the future to pending
+	// if the iroh feature is disabled.
+	#[cfg(not(feature = "iroh"))]
+	let iroh_fut = Box::pin(std::future::pending::<anyhow::Result<()>>()) as Pin<Box<dyn Future<Output = _>>>;
 
 	// Get the first certificate's fingerprint.
 	// TODO serve all of them so we can support multiple signature algorithms.
@@ -35,20 +57,19 @@ pub async fn server(
 
 	tokio::select! {
 		res = accept(server, name, publish.consume()) => res,
+		res = iroh_fut => res,
 		res = publish.run() => res,
 		res = web(listen, fingerprint, public) => res,
 	}
 }
 
 async fn accept(
-	mut server: moq_native::Server,
+	mut server: impl moq_native::MoqServer,
 	name: String,
 	consumer: moq_lite::BroadcastConsumer,
 ) -> anyhow::Result<()> {
 	let mut conn_id = 0;
 
-	tracing::info!(addr = ?server.local_addr(), "listening");
-
 	while let Some(session) = server.accept().await {
 		let id = conn_id;
 		conn_id += 1;
@@ -80,8 +101,15 @@ async fn run_session(
 	// Create an origin producer to publish to the broadcast.
 	let origin = moq_lite::Origin::produce();
 	origin.producer.publish_broadcast(&name, consumer);
+	match session {
+		moq_native::Session::Quinn(session) => run_session_inner(id, session, origin.consumer).await,
+		#[cfg(feature = "iroh")]
+		moq_native::Session::Iroh(session) => run_session_inner(id, session, origin.consumer).await,
+	}
+}
 
-	let session = moq_lite::Session::accept(session, origin.consumer, None)
+async fn run_session_inner<S: Session>(id: u64, session: S, consumer: moq_lite::OriginConsumer) -> anyhow::Result<()> {
+	let session = moq_lite::Session::accept(session, consumer, None)
 		.await
 		.context("failed to accept session")?;
 

rs/moq-native/Cargo.toml

@@ -15,6 +15,7 @@ categories = ["multimedia", "network-programming", "web-programming"]
 default = ["aws-lc-rs"]
 aws-lc-rs = ["rustls/aws-lc-rs", "rcgen/aws_lc_rs", "quinn/rustls-aws-lc-rs"]
 ring = ["rustls/ring", "rcgen/ring", "quinn/rustls-ring"]
+iroh = ["dep:web-transport-iroh"]
 
 [dependencies]
 anyhow = { version = "1", features = ["backtrace"] }
@@ -42,6 +43,8 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 url = "2"
 web-transport-quinn = { workspace = true }
+web-transport-iroh = { git = "https://github.com/n0-computer/iroh-live", optional = true }
+rand = "0.9.2"
 
 [dev-dependencies]
 anyhow = "1"