{
104 | Ok(self.addr)
105 | }
106 | }
107 |
108 | impl Drop for VirtualUdpSocket {
109 | fn drop(&mut self) {
110 | if let Err(e) = self.close_socket_tx.send(self.port) {
111 | log::error!("Failed to send close socket: {:?}", e);
112 | }
113 | }
114 | }
115 |
--------------------------------------------------------------------------------
/examples/whip-whep/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "whip-whep"
3 | version.workspace = true
4 | edition.workspace = true
5 | publish.workspace = true
6 |
7 | [dependencies]
8 | atm0s-sdn = { path = "../../packages/runner" }
9 | derive_more = "0.99.17"
10 | str0m = "0.5.0"
11 | tiny_http = "0.12.0"
12 | signal-hook = "0.3.17"
13 | env_logger = "0.11.3"
14 | log.workspace = true
15 | faster-stun = "1.0.2"
16 | clap.workspace = true
17 | serde = "1.0.197"
18 | bincode = "1.3.3"
19 | rand = "0.8.5"
20 | convert-enum = "0.1.0"
21 |
--------------------------------------------------------------------------------
/examples/whip-whep/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
9 |
10 |
--------------------------------------------------------------------------------
/examples/whip-whep/public/whep/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Whep
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/examples/whip-whep/public/whep/whep.demo.js:
--------------------------------------------------------------------------------
1 | import { WHEPClient } from "./whep.js"
2 |
3 | window.start = async () => {
4 | console.log("Will start");
5 | //Create peerconnection
6 | const pc = window.pc = new RTCPeerConnection();
7 |
8 | //Add recv only transceivers
9 | pc.addTransceiver("audio", { direction: 'recvonly' });
10 | pc.addTransceiver("video", { direction: 'recvonly' });
11 |
12 | let stream = new MediaStream();
13 | document.querySelector("video").srcObject = stream;
14 | pc.ontrack = (event) => {
15 | stream.addTrack(event.track);
16 | }
17 |
18 | //Create whep client
19 | const whep = new WHEPClient();
20 |
21 | const url = "/whep/endpoint";
22 | const token = document.getElementById("room-id").value;
23 |
24 | //Start viewing
25 | whep.view(pc, url, token);
26 |
27 | window.whep_instance = whep;
28 | }
29 |
30 | window.stop = async () => {
31 | if (window.whep_instance) {
32 | window.whep_instance.stop();
33 | }
34 |
35 | document.getElementById("video").srcObject = null;
36 | }
--------------------------------------------------------------------------------
/examples/whip-whep/public/whip/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Whip
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/examples/whip-whep/public/whip/whip.demo.js:
--------------------------------------------------------------------------------
1 | import { WHIPClient } from "./whip.js"
2 |
3 | window.start = async () => {
4 | console.log("Will start");
5 | if (window.whip_instance) {
6 | window.whip_instance.stop();
7 | }
8 |
9 | if (window.stream_instance) {
10 | window.stream_instance.getTracks().forEach(track => track.stop());
11 | }
12 |
13 | //Get mic+cam
14 | const stream = await navigator.mediaDevices.getUserMedia({audio:true, video:true});
15 |
16 | document.getElementById("video").srcObject = stream;
17 |
18 | //Create peerconnection
19 | const pc = new RTCPeerConnection();
20 |
21 | //Send all tracks
22 | for (const track of stream.getTracks()) {
23 | //You could add simulcast too here
24 | pc.addTransceiver(track, {
25 | direction: "sendonly",
26 | streams: [stream],
27 | // sendEncodings: [
28 | // { rid: "0", active: true, scaleResolutionDownBy: 2},
29 | // { rid: "1", active: true, scaleResolutionDownBy: 2},
30 | // { rid: "2", active: true },
31 | // ],
32 | });
33 | }
34 |
35 | //Create whip client
36 | const whip = new WHIPClient();
37 |
38 | const url = "/whip/endpoint";
39 | const token = document.getElementById("room-id").value;
40 |
41 | //Start publishing
42 | whip.publish(pc, url, token);
43 |
44 | window.whip_instance = whip;
45 | window.stream_instance = stream;
46 | }
47 |
48 | window.stop = async () => {
49 | if (window.whip_instance) {
50 | window.whip_instance.stop();
51 | }
52 |
53 | if (window.stream_instance) {
54 | window.stream_instance.getTracks().forEach(track => track.stop());
55 | }
56 |
57 | document.getElementById("video").srcObject = null;
58 | }
--------------------------------------------------------------------------------
/examples/whip-whep/src/http.rs:
--------------------------------------------------------------------------------
1 | use std::io::Read;
2 | use std::{collections::HashMap, fs::File, net::SocketAddr, path::Path, time::Duration};
3 | use tiny_http::{Header, Method, Request, Response, Server};
4 |
5 | #[derive(Debug, Clone)]
6 | pub struct HttpRequest {
7 | pub req_id: u64,
8 | pub method: String,
9 | pub path: String,
10 | pub headers: HashMap,
11 | pub body: Vec,
12 | }
13 |
14 | impl HttpRequest {
15 | pub fn http_auth(&self) -> String {
16 | if let Some(auth) = self.headers.get("Authorization") {
17 | auth.clone()
18 | } else if let Some(auth) = self.headers.get("authorization") {
19 | auth.clone()
20 | } else {
21 | "demo".to_string()
22 | }
23 | }
24 | }
25 |
26 | #[derive(Debug, Clone)]
27 | pub struct HttpResponse {
28 | pub req_id: u64,
29 | pub status: u16,
30 | pub headers: HashMap,
31 | pub body: Vec,
32 | }
33 |
34 | pub struct SimpleHttpServer {
35 | req_id_seed: u64,
36 | server: Server,
37 | reqs: HashMap,
38 | }
39 |
40 | impl SimpleHttpServer {
41 | pub fn new(port: u16) -> Self {
42 | Self {
43 | req_id_seed: 0,
44 | server: Server::http(SocketAddr::from(([0, 0, 0, 0], port))).expect("Should open http port"),
45 | reqs: HashMap::new(),
46 | }
47 | }
48 |
49 | pub fn send_response(&mut self, res: HttpResponse) {
50 | log::info!("sending response for request_id {}, status {}", res.req_id, res.status);
51 | let req = self.reqs.remove(&res.req_id).expect("Should have a request.");
52 | let mut response = Response::from_data(res.body).with_status_code(res.status);
53 | for (k, v) in res.headers {
54 | response.add_header(Header::from_bytes(k.as_bytes(), v.as_bytes()).unwrap());
55 | }
56 | response.add_header(Header::from_bytes("Access-Control-Allow-Origin", "*").unwrap());
57 | response.add_header(Header::from_bytes("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS").unwrap());
58 | response.add_header(Header::from_bytes("Access-Control-Allow-Headers", "*").unwrap());
59 | response.add_header(Header::from_bytes("Access-Control-Allow-Credentials", "true").unwrap());
60 | req.respond(response).unwrap();
61 | }
62 |
63 | pub fn recv(&mut self, timeout: Duration) -> Result, std::io::Error> {
64 | let mut request = if let Some(req) = self.server.recv_timeout(timeout)? {
65 | req
66 | } else {
67 | return Ok(None);
68 | };
69 | if request.url().starts_with("/public") {
70 | if let Ok(file) = File::open(&Path::new(&format!(".{}", request.url()))) {
71 | let mut response = tiny_http::Response::from_file(file);
72 | if request.url().ends_with(".js") {
73 | response.add_header(Header::from_bytes("Content-Type", "application/javascript").unwrap());
74 | } else if request.url().ends_with(".css") {
75 | response.add_header(Header::from_bytes("Content-Type", "text/css").unwrap());
76 | }
77 | request.respond(response).expect("Should respond file.");
78 | return Ok(None);
79 | } else {
80 | let response = Response::from_string("Not Found");
81 | request.respond(response.with_status_code(404)).expect("Should respond 404.");
82 | return Ok(None);
83 | }
84 | }
85 |
86 | if request.method().eq(&Method::Options) {
87 | let mut response = Response::from_string("OK");
88 | //setting CORS
89 | response.add_header(Header::from_bytes("Access-Control-Allow-Origin", "*").unwrap());
90 | response.add_header(Header::from_bytes("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS").unwrap());
91 | response.add_header(Header::from_bytes("Access-Control-Allow-Headers", "*").unwrap());
92 | response.add_header(Header::from_bytes("Access-Control-Allow-Credentials", "true").unwrap());
93 |
94 | request.respond(response).expect("Should respond options.");
95 | return Ok(None);
96 | }
97 |
98 | log::info!("received request_id {} method: {}, url: {}", self.req_id_seed, request.method(), request.url(),);
99 |
100 | let req_id = self.req_id_seed;
101 | self.req_id_seed += 1;
102 |
103 | let res = Ok(Some(HttpRequest {
104 | req_id,
105 | method: request.method().to_string(),
106 | path: request.url().to_string(),
107 | headers: request.headers().iter().map(|h| (h.field.to_string(), h.value.to_string())).collect(),
108 | body: request.as_reader().bytes().map(|b| b.unwrap()).collect(),
109 | }));
110 | self.reqs.insert(req_id, request);
111 | res
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/examples/whip-whep/src/main.rs:
--------------------------------------------------------------------------------
1 | use std::{
2 | net::SocketAddr,
3 | sync::{
4 | atomic::{AtomicBool, Ordering},
5 | Arc,
6 | },
7 | time::Duration,
8 | vec,
9 | };
10 |
11 | use atm0s_sdn::sans_io_runtime::{backend::PollingBackend, Controller};
12 | use atm0s_sdn::{
13 | base::ServiceBuilder,
14 | features::{FeaturesControl, FeaturesEvent},
15 | secure::{HandshakeBuilderXDA, StaticKeyAuthorization},
16 | services::visualization,
17 | DataWorkerHistory, NodeAddr, NodeAddrBuilder, NodeId, Protocol, SdnExtIn,
18 | };
19 | use clap::Parser;
20 |
21 | use worker::{ChannelId, Event, ExtIn, ExtOut, ICfg, SCfg, SC, SE, TC, TW};
22 |
23 | use crate::worker::{ControllerCfg, RunnerOwner, RunnerWorker, SdnInnerCfg};
24 |
25 | mod http;
26 | mod sfu;
27 | mod worker;
28 |
29 | /// Quic-tunnel demo application
30 | #[derive(Parser, Debug)]
31 | #[command(version, about, long_about = None)]
32 | struct Args {
33 | /// Node Id
34 | #[arg(env, short, long, default_value_t = 1)]
35 | node_id: NodeId,
36 |
37 | /// Listen address
38 | #[arg(env, short, long, default_value_t = 10000)]
39 | udp_port: u16,
40 |
41 | /// Address of node we should connect to
42 | #[arg(env, short, long)]
43 | seeds: Vec,
44 |
45 | /// Password for the network
46 | #[arg(env, short, long, default_value = "password")]
47 | password: String,
48 |
49 | /// Workers
50 | #[arg(env, long, default_value_t = 1)]
51 | workers: usize,
52 |
53 | /// Http listen port
54 | #[arg(env, long, default_value_t = 8080)]
55 | http_port: u16,
56 | }
57 |
58 | fn main() {
59 | if std::env::var_os("RUST_LOG").is_none() {
60 | std::env::set_var("RUST_LOG", "info");
61 | }
62 | let args = Args::parse();
63 | env_logger::builder().format_timestamp_millis().init();
64 |
65 | let auth = Arc::new(StaticKeyAuthorization::new(&args.password));
66 | let history = Arc::new(DataWorkerHistory::default());
67 |
68 | let mut server = http::SimpleHttpServer::new(args.http_port);
69 | let mut controller = Controller::::default();
70 | let services: Vec>> = vec![Arc::new(visualization::VisualizationServiceBuilder::<(), SC, SE, TC, TW>::new(false))];
71 |
72 | let mut addr_builder = NodeAddrBuilder::new(args.node_id);
73 | addr_builder.add_protocol(Protocol::Ip4("192.168.1.39".parse().unwrap()));
74 | addr_builder.add_protocol(Protocol::Udp(args.udp_port));
75 | let addr = addr_builder.addr();
76 | log::info!("Node address: {}", addr);
77 |
78 | controller.add_worker::>(
79 | Duration::from_millis(10),
80 | ICfg {
81 | sfu: "192.168.1.39:0".parse().unwrap(),
82 | sdn: SdnInnerCfg {
83 | node_id: args.node_id,
84 | tick_ms: 1000,
85 | controller: Some(ControllerCfg {
86 | session: 0,
87 | auth,
88 | handshake: Arc::new(HandshakeBuilderXDA),
89 | }),
90 | services: services.clone(),
91 | history: history.clone(),
92 | #[cfg(feature = "vpn")]
93 | vpn_tun_fd: None,
94 | },
95 | sdn_listen: SocketAddr::from(([0, 0, 0, 0], args.udp_port)),
96 | },
97 | None,
98 | );
99 |
100 | for _ in 1..args.workers {
101 | controller.add_worker::>(
102 | Duration::from_millis(10),
103 | ICfg {
104 | sfu: "192.168.1.39:0".parse().unwrap(),
105 | sdn: SdnInnerCfg {
106 | node_id: args.node_id,
107 | tick_ms: 1000,
108 | controller: None,
109 | services: services.clone(),
110 | history: history.clone(),
111 | #[cfg(feature = "vpn")]
112 | vpn_tun_fd: None,
113 | },
114 | sdn_listen: SocketAddr::from(([0, 0, 0, 0], args.udp_port)),
115 | },
116 | None,
117 | );
118 | }
119 |
120 | for seed in args.seeds {
121 | controller.send_to(0, ExtIn::Sdn(SdnExtIn::ConnectTo(seed)));
122 | }
123 |
124 | // let term = Arc::new(AtomicBool::new(false));
125 | // signal_hook::flag::register(signal_hook::consts::SIGINT, Arc::clone(&term)).expect("Should register hook");
126 |
127 | while let Ok(req) = server.recv(Duration::from_millis(100)) {
128 | if controller.process().is_none() {
129 | break;
130 | }
131 | // if term.load(Ordering::Relaxed) {
132 | // controller.shutdown();
133 | // }
134 | while let Some(ext) = controller.pop_event() {
135 | match ext {
136 | ExtOut::HttpResponse(resp) => {
137 | server.send_response(resp);
138 | }
139 | ExtOut::Sdn(event) => {}
140 | }
141 | }
142 | if let Some(req) = req {
143 | controller.send_to_best(ExtIn::HttpRequest(req));
144 | }
145 | }
146 |
147 | log::info!("Server shutdown");
148 | }
149 |
--------------------------------------------------------------------------------
/examples/whip-whep/src/sfu/cluster.rs:
--------------------------------------------------------------------------------
1 | use std::{
2 | collections::HashMap,
3 | hash::{DefaultHasher, Hash, Hasher},
4 | time::Instant,
5 | };
6 |
7 | use atm0s_sdn::features::pubsub::{self, ChannelControl, Feedback};
8 | use str0m::media::KeyframeRequestKind;
9 |
10 | use super::{TrackMedia, WhepOwner, WhipOwner};
11 |
12 | pub fn room_channel(room: &str) -> u64 {
13 | let mut hasher = DefaultHasher::new();
14 | room.hash(&mut hasher);
15 | hasher.finish()
16 | }
17 |
18 | pub enum Input {
19 | Pubsub(pubsub::Event),
20 | WhipStart(WhipOwner, String),
21 | WhipStop(WhipOwner),
22 | WhipMedia(WhipOwner, TrackMedia),
23 | WhepStart(WhepOwner, String),
24 | WhepStop(WhepOwner),
25 | WhepRequest(WhepOwner, KeyframeRequestKind),
26 | }
27 |
28 | pub enum Output {
29 | Pubsub(pubsub::Control),
30 | WhepMedia(Vec, TrackMedia),
31 | WhipControl(Vec, KeyframeRequestKind),
32 | }
33 |
34 | pub struct Channel {
35 | whips: Vec,
36 | wheps: Vec,
37 | }
38 |
39 | #[derive(Default)]
40 | pub struct ClusterLogic {
41 | channels: HashMap,
42 | whips: HashMap,
43 | wheps: HashMap,
44 | }
45 |
46 | impl ClusterLogic {
47 | pub fn on_input(&mut self, now: Instant, input: Input) -> Option