917 lines
29 KiB
Rust
917 lines
29 KiB
Rust
//! End-to-end test on the virtual adapter: scanning, channels, M3U, ACL, HLS,
|
||
//! MPEG-TS, EPG/XMLTV, sharing and recording.
|
||
|
||
use axum::body::Body;
|
||
use axum::extract::connect_info::MockConnectInfo;
|
||
use axum::http::{header, Method, Request, StatusCode};
|
||
use axum::Router;
|
||
use http_body_util::BodyExt;
|
||
use serde_json::{json, Value};
|
||
use simply_dvb::app::{AppState, Options, State};
|
||
use simply_dvb::db::Db;
|
||
use simply_dvb::ts::testgen::GenMux;
|
||
use simply_dvb::{auth, epg, recorder, web};
|
||
use std::net::SocketAddr;
|
||
use std::time::Duration;
|
||
use tower::ServiceExt;
|
||
|
||
struct Env {
|
||
state: State,
|
||
lan: Router,
|
||
wan: Router,
|
||
cookie: String,
|
||
_dir: tempfile::TempDir,
|
||
}
|
||
|
||
async fn setup() -> Env {
|
||
let _ = tracing_subscriber::fmt()
|
||
.with_env_filter("simply_dvb=debug")
|
||
.with_test_writer()
|
||
.try_init();
|
||
std::env::set_var("SIMPLY_DVB_VIRTUAL_SPEED", "4");
|
||
let dir = tempfile::tempdir().unwrap();
|
||
let mux_dir = dir.path().join("muxes");
|
||
std::fs::create_dir_all(&mux_dir).unwrap();
|
||
let t = chrono::Utc::now().timestamp();
|
||
let mut m = GenMux::sample(0x0003, 0x0451, &["TVP1 HD", "Polsat Śląsk", "TVN"], t);
|
||
m.other_muxes = vec![(0x0004, 610_000_000)];
|
||
std::fs::write(mux_dir.join("538.ts"), m.generate(40)).unwrap();
|
||
// second mux – known only from the first one's NIT (network discovery)
|
||
let m2 = GenMux::sample(0x0004, 0x0500, &["Radio Test"], t);
|
||
std::fs::write(mux_dir.join("610.ts"), m2.generate(4)).unwrap();
|
||
|
||
let db = Db::open(&dir.path().join("t.db")).await.unwrap();
|
||
db.create_user(
|
||
"admin",
|
||
&auth::hash_password("haslo-admina").unwrap(),
|
||
"admin",
|
||
)
|
||
.await
|
||
.unwrap();
|
||
db.create_user(
|
||
"widz",
|
||
&auth::hash_password("haslo-widza").unwrap(),
|
||
"viewer",
|
||
)
|
||
.await
|
||
.unwrap();
|
||
let opts = Options {
|
||
data_dir: dir.path().to_path_buf(),
|
||
dev_root: dir.path().join("brak-dvb").to_string_lossy().to_string(),
|
||
virtual_dirs: vec![mux_dir.to_string_lossy().to_string()],
|
||
stream_port: Some(9981),
|
||
htsp_port: None,
|
||
panel_port: 9980,
|
||
};
|
||
let (state, epg_rx) = AppState::new(db, opts).await.unwrap();
|
||
tokio::spawn(epg::writer_task(state.clone(), epg_rx));
|
||
tokio::spawn(recorder::scheduler_task(state.clone()));
|
||
let st = state.clone();
|
||
tokio::spawn(async move {
|
||
loop {
|
||
tokio::time::sleep(Duration::from_millis(500)).await;
|
||
st.tuners.reap();
|
||
st.hls.reap();
|
||
}
|
||
});
|
||
let lan = web::router(state.clone())
|
||
.layer(MockConnectInfo(SocketAddr::from(([192, 168, 1, 50], 5000))));
|
||
let wan =
|
||
web::router(state.clone()).layer(MockConnectInfo(SocketAddr::from(([8, 8, 8, 8], 5000))));
|
||
let mut env = Env {
|
||
state,
|
||
lan,
|
||
wan,
|
||
cookie: String::new(),
|
||
_dir: dir,
|
||
};
|
||
env.cookie = login(&env.lan, "admin", "haslo-admina").await;
|
||
env
|
||
}
|
||
|
||
async fn login(r: &Router, user: &str, pw: &str) -> String {
|
||
let res = r
|
||
.clone()
|
||
.oneshot(
|
||
Request::post("/api/login")
|
||
.header(header::CONTENT_TYPE, "application/json")
|
||
.header("x-requested-with", "simply-dvb")
|
||
.body(Body::from(
|
||
json!({"username": user, "password": pw}).to_string(),
|
||
))
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::OK);
|
||
let c = res
|
||
.headers()
|
||
.get(header::SET_COOKIE)
|
||
.unwrap()
|
||
.to_str()
|
||
.unwrap();
|
||
c.split(';').next().unwrap().to_string()
|
||
}
|
||
|
||
async fn call(
|
||
r: &Router,
|
||
method: Method,
|
||
uri: &str,
|
||
cookie: &str,
|
||
body: Option<Value>,
|
||
) -> (StatusCode, Vec<u8>) {
|
||
let mut b = Request::builder()
|
||
.method(method)
|
||
.uri(uri)
|
||
.header("x-requested-with", "simply-dvb");
|
||
if !cookie.is_empty() {
|
||
b = b.header(header::COOKIE, cookie);
|
||
}
|
||
let req = match body {
|
||
Some(v) => b
|
||
.header(header::CONTENT_TYPE, "application/json")
|
||
.body(Body::from(v.to_string()))
|
||
.unwrap(),
|
||
None => b.body(Body::empty()).unwrap(),
|
||
};
|
||
let res = r.clone().oneshot(req).await.unwrap();
|
||
let st = res.status();
|
||
let bytes = res.into_body().collect().await.unwrap().to_bytes().to_vec();
|
||
(st, bytes)
|
||
}
|
||
|
||
async fn json_of(
|
||
r: &Router,
|
||
method: Method,
|
||
uri: &str,
|
||
cookie: &str,
|
||
body: Option<Value>,
|
||
) -> Value {
|
||
let (st, b) = call(r, method, uri, cookie, body).await;
|
||
assert!(
|
||
st.is_success(),
|
||
"{uri}: {st} {}",
|
||
String::from_utf8_lossy(&b)
|
||
);
|
||
serde_json::from_slice(&b).unwrap()
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
||
async fn full_flow() {
|
||
let env = setup().await;
|
||
let c = env.cookie.clone();
|
||
|
||
eprintln!("== setup ok");
|
||
// no session -> 401, missing CSRF header -> 403
|
||
let (st, _) = call(&env.lan, Method::GET, "/api/channels", "", None).await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
let res = env
|
||
.lan
|
||
.clone()
|
||
.oneshot(
|
||
Request::post("/api/scan")
|
||
.header(header::COOKIE, &c)
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::FORBIDDEN);
|
||
|
||
// virtual adapter
|
||
let ad = json_of(&env.lan, Method::GET, "/api/adapters", &c, None).await;
|
||
assert_eq!(ad.as_array().unwrap().len(), 1);
|
||
assert_eq!(ad[0]["device"]["bus"], "virtual");
|
||
|
||
// profile: preferences, signed-in devices, viewing statistics, PWA manifest
|
||
json_of(
|
||
&env.lan,
|
||
Method::PUT,
|
||
"/api/me/prefs",
|
||
&c,
|
||
Some(json!({"sdvb-lang": "pl_PL", "sdvb-fav": "[1,2]"})),
|
||
)
|
||
.await;
|
||
let prefs = json_of(&env.lan, Method::GET, "/api/me/prefs", &c, None).await;
|
||
assert_eq!(prefs["sdvb-fav"], "[1,2]");
|
||
let sessions = json_of(&env.lan, Method::GET, "/api/me/sessions", &c, None).await;
|
||
assert!(sessions
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|s| s["current"] == true));
|
||
let views = json_of(&env.lan, Method::GET, "/api/stats/viewing?days=7", &c, None).await;
|
||
assert_eq!(views["hours"].as_array().unwrap().len(), 24);
|
||
let (st, body) = call(&env.lan, Method::GET, "/manifest.webmanifest", "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
assert!(String::from_utf8_lossy(&body).contains("standalone"));
|
||
|
||
eprintln!("== adapters ok");
|
||
// scanning
|
||
json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/scan",
|
||
&c,
|
||
Some(json!({"preset": "custom", "frequencies_mhz": [538, 546]})),
|
||
)
|
||
.await;
|
||
let mut done = false;
|
||
for _ in 0..100 {
|
||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||
let s = json_of(&env.lan, Method::GET, "/api/scan", &c, None).await;
|
||
if !s["running"].as_bool().unwrap() {
|
||
assert_eq!(s["muxes_found"], 2, "{s}");
|
||
assert_eq!(s["services_found"], 4);
|
||
assert_eq!(s["channels_created"], 4);
|
||
done = true;
|
||
break;
|
||
}
|
||
}
|
||
assert!(done, "scan did not finish");
|
||
|
||
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
|
||
let chans = chans.as_array().unwrap();
|
||
assert_eq!(chans.len(), 4);
|
||
assert_eq!(chans[0]["name"], "TVP1 HD");
|
||
assert_eq!(chans[0]["number"], 1);
|
||
assert_eq!(chans[1]["name"], "Polsat Śląsk");
|
||
assert_eq!(chans[1]["service"]["video"], "HEVC");
|
||
let id1 = chans[0]["id"].as_i64().unwrap();
|
||
let id2 = chans[1]["id"].as_i64().unwrap();
|
||
|
||
// reordering
|
||
json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/channels/order",
|
||
&c,
|
||
Some(json!({"ids": [id2, id1]})),
|
||
)
|
||
.await;
|
||
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
|
||
assert_eq!(chans[0]["id"].as_i64().unwrap(), id2);
|
||
|
||
// a viewer cannot change the configuration
|
||
let vc = login(&env.lan, "widz", "haslo-widza").await;
|
||
let (st, _) = call(
|
||
&env.lan,
|
||
Method::PUT,
|
||
&format!("/api/channels/{id1}"),
|
||
&vc,
|
||
Some(json!({"name": "X"})),
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::FORBIDDEN);
|
||
|
||
// M3U: LAN without a token, WAN requires a token
|
||
let (st, body) = call(&env.lan, Method::GET, "/playlist.m3u", "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let m3u = String::from_utf8(body).unwrap();
|
||
assert!(m3u.starts_with("#EXTM3U"));
|
||
assert!(m3u.contains(&format!("/stream/{id1}.ts")));
|
||
let (st, _) = call(&env.wan, Method::GET, "/playlist.m3u", "", None).await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
let tok = json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/tokens",
|
||
&c,
|
||
Some(json!({"name": "Sony TV"})),
|
||
)
|
||
.await;
|
||
let token = tok["token"].as_str().unwrap().to_string();
|
||
let (st, body) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/playlist.m3u?format=hls&token={token}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let m3u = String::from_utf8(body).unwrap();
|
||
assert!(
|
||
m3u.contains(&format!("/hls/{id1}/index.m3u8?token={token}")),
|
||
"{m3u}"
|
||
);
|
||
// token restricted to a network
|
||
let tok2 = json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/tokens",
|
||
&c,
|
||
Some(json!({"name": "Tylko LAN", "allow_cidrs": "192.168.0.0/16"})),
|
||
)
|
||
.await;
|
||
let (st, _) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/playlist.m3u?token={}", tok2["token"].as_str().unwrap()),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
|
||
// ---- tvheadend compatibility
|
||
let (st, body) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/playlist?auth={token}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let tvh = String::from_utf8(body).unwrap();
|
||
assert!(
|
||
tvh.contains(&format!(
|
||
"/stream/channelid/{id1}?auth={token}&profile=pass"
|
||
)),
|
||
"{tvh}"
|
||
);
|
||
assert!(tvh.contains("tvg-id=\"") && tvh.contains("tvg-chno=\"1\""));
|
||
for path in [
|
||
"/playlist/channels",
|
||
"/playlist/channels.m3u",
|
||
"/playlist/auth/channels",
|
||
] {
|
||
let (st, _) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("{path}?ticket={token}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK, "{path}");
|
||
}
|
||
let (st, one) = call(
|
||
&env.lan,
|
||
Method::GET,
|
||
&format!("/playlist/channelid/{id1}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
assert_eq!(
|
||
String::from_utf8(one).unwrap().matches("#EXTINF").count(),
|
||
1
|
||
);
|
||
// HTTP Basic with a panel login (like tvheadend clients)
|
||
let basic = format!("Basic {}", base64_encode("admin:haslo-admina"));
|
||
let res = env
|
||
.wan
|
||
.clone()
|
||
.oneshot(
|
||
Request::get("/xmltv/channels")
|
||
.header(header::AUTHORIZATION, &basic)
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::OK);
|
||
let res = env
|
||
.wan
|
||
.clone()
|
||
.oneshot(
|
||
Request::get("/xmltv/channels")
|
||
.header(
|
||
header::AUTHORIZATION,
|
||
format!("Basic {}", base64_encode("admin:zle")),
|
||
)
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
|
||
// stream by channel number
|
||
let res = env
|
||
.lan
|
||
.clone()
|
||
.oneshot(
|
||
Request::get("/stream/channelnumber/2?profile=webtv-h264-aac-mpegts-unknown")
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::OK);
|
||
let mut b = res.into_body();
|
||
let f = tokio::time::timeout(Duration::from_secs(10), b.frame())
|
||
.await
|
||
.unwrap()
|
||
.unwrap()
|
||
.unwrap();
|
||
assert_eq!(f.into_data().unwrap()[0], 0x47);
|
||
drop(b);
|
||
let (st, _) = call(&env.lan, Method::GET, "/stream/channelid/99999", "", None).await;
|
||
assert_eq!(st, StatusCode::NOT_FOUND);
|
||
// separate stream port: no panel and no API
|
||
let stream_port = web::stream_router(env.state.clone())
|
||
.layer(MockConnectInfo(SocketAddr::from(([192, 168, 1, 60], 5000))));
|
||
let (st, _) = call(&stream_port, Method::GET, "/playlist", "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let (st, _) = call(&stream_port, Method::GET, "/api/channels", &c, None).await;
|
||
assert_eq!(st, StatusCode::NOT_FOUND);
|
||
// tvheadend JSON API (PVR Live and other Android TV sources)
|
||
let (st, body) = call(&stream_port, Method::GET, "/api/serverinfo", "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let info: serde_json::Value = serde_json::from_slice(&body).unwrap();
|
||
assert_eq!(info["name"], "Tvheadend");
|
||
let (_, body) = call(
|
||
&stream_port,
|
||
Method::GET,
|
||
"/api/channel/grid?limit=999",
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
let grid: serde_json::Value = serde_json::from_slice(&body).unwrap();
|
||
let first = &grid["entries"][0];
|
||
assert_eq!(grid["total"], 4);
|
||
assert!(first["name"].is_string());
|
||
let uuid = first["uuid"].as_str().unwrap().to_string();
|
||
let (_, body) = call(
|
||
&stream_port,
|
||
Method::GET,
|
||
&format!("/api/epg/events/grid?channel={uuid}&limit=5"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
let epg: serde_json::Value = serde_json::from_slice(&body).unwrap();
|
||
// EIT has not been collected yet at this point: only the shape is checked
|
||
assert!(epg["entries"].is_array(), "{epg}");
|
||
assert!(epg["totalCount"].is_number());
|
||
let _ = uuid;
|
||
// the WAN side needs a token here too
|
||
let wan_stream = web::stream_router(env.state.clone())
|
||
.layer(MockConnectInfo(SocketAddr::from(([8, 8, 8, 8], 5000))));
|
||
let (st, _) = call(&wan_stream, Method::GET, "/api/channel/grid", "", None).await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
let (st, _) = call(
|
||
&wan_stream,
|
||
Method::GET,
|
||
&format!("/api/channel/grid?auth={token}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
|
||
// HLS
|
||
let (st, body) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/hls/{id1}/index.m3u8?token={token}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK, "{}", String::from_utf8_lossy(&body));
|
||
let pl = String::from_utf8(body).unwrap();
|
||
assert!(pl.contains("#EXT-X-TARGETDURATION"));
|
||
let seg_line = pl
|
||
.lines()
|
||
.find(|l| l.ends_with(&format!("?token={token}")))
|
||
.expect("segment in playlist")
|
||
.to_string();
|
||
let (st, seg) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/hls/{id1}/{seg_line}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
assert!(seg.len() > 188 * 10 && seg.len() % 188 == 0);
|
||
assert_eq!(seg[0], 0x47);
|
||
// second channel from the same mux shares the tuner
|
||
let (st, _) = call(
|
||
&env.lan,
|
||
Method::GET,
|
||
&format!("/hls/{id2}/index.m3u8"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let status = json_of(&env.lan, Method::GET, "/api/status", &c, None).await;
|
||
assert_eq!(status["tuners"][0]["active"]["state"], "locked");
|
||
assert_eq!(status["hls_sessions"].as_array().unwrap().len(), 2);
|
||
|
||
// raw MPEG-TS
|
||
let res = env
|
||
.lan
|
||
.clone()
|
||
.oneshot(
|
||
Request::get(format!("/stream/{id1}.ts"))
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::OK);
|
||
assert_eq!(res.headers()[header::CONTENT_TYPE], "video/mp2t");
|
||
let mut body = res.into_body();
|
||
let frame = tokio::time::timeout(Duration::from_secs(10), body.frame())
|
||
.await
|
||
.unwrap()
|
||
.unwrap()
|
||
.unwrap();
|
||
let data = frame.into_data().unwrap();
|
||
assert_eq!(data[0], 0x47);
|
||
drop(body);
|
||
|
||
// EPG from EIT -> XMLTV
|
||
let mut found = false;
|
||
for _ in 0..40 {
|
||
let (st, body) = call(&env.lan, Method::GET, "/epg.xml", "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let x = String::from_utf8(body).unwrap();
|
||
if x.contains("<programme") && x.contains("TVP1 HD - audycja 1") {
|
||
assert!(x.contains("<channel id=\""));
|
||
found = true;
|
||
break;
|
||
}
|
||
tokio::time::sleep(Duration::from_millis(250)).await;
|
||
}
|
||
assert!(found, "no EPG in XMLTV");
|
||
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
|
||
assert!(
|
||
chans
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|ch| !ch["now"].is_null()),
|
||
"no current programme"
|
||
);
|
||
|
||
// public sharing
|
||
let sh = json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
&format!("/api/channels/{id1}/share"),
|
||
&c,
|
||
Some(json!({"enabled": true})),
|
||
)
|
||
.await;
|
||
let share = sh["token"].as_str().unwrap().to_string();
|
||
let (st, page) = call(&env.wan, Method::GET, &format!("/watch/{share}"), "", None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
assert!(String::from_utf8_lossy(&page).contains("TVP1 HD"));
|
||
let (st, _) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/hls/{id1}/index.m3u8?share={share}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let (st, _) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/hls/{id2}/index.m3u8?share={share}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
let (st, _) = call(
|
||
&env.wan,
|
||
Method::GET,
|
||
&format!("/playlist.m3u?share={share}"),
|
||
"",
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
&format!("/api/channels/{id1}/share"),
|
||
&c,
|
||
Some(json!({"enabled": false})),
|
||
)
|
||
.await;
|
||
let (st, _) = call(&env.wan, Method::GET, &format!("/watch/{share}"), "", None).await;
|
||
assert_eq!(st, StatusCode::NOT_FOUND);
|
||
|
||
// manual recording (about 8 s of stream at 4x speed)
|
||
let now = chrono::Utc::now().timestamp();
|
||
let rec = json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/recordings",
|
||
&c,
|
||
Some(json!({"channel_id": id1, "title": "Test recording", "start": now, "stop": now + 8})),
|
||
)
|
||
.await;
|
||
let rid = rec["id"].as_i64().unwrap();
|
||
let mut status = String::new();
|
||
for _ in 0..120 {
|
||
tokio::time::sleep(Duration::from_millis(250)).await;
|
||
let r = json_of(&env.lan, Method::GET, "/api/recordings", &c, None).await;
|
||
status = r[0]["status"].as_str().unwrap().to_string();
|
||
if status == "completed" || status == "failed" {
|
||
break;
|
||
}
|
||
}
|
||
assert_eq!(status, "completed");
|
||
let (st, pl) = call(
|
||
&env.lan,
|
||
Method::GET,
|
||
&format!("/recordings/{rid}/index.m3u8"),
|
||
&c,
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let pl = String::from_utf8(pl).unwrap();
|
||
assert!(
|
||
pl.contains("#EXT-X-BYTERANGE:") && pl.contains("#EXT-X-ENDLIST"),
|
||
"{pl}"
|
||
);
|
||
let res = env
|
||
.lan
|
||
.clone()
|
||
.oneshot(
|
||
Request::get(format!("/recordings/{rid}/file"))
|
||
.header(header::COOKIE, &c)
|
||
.header(header::RANGE, "bytes=0-187")
|
||
.body(Body::empty())
|
||
.unwrap(),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(res.status(), StatusCode::PARTIAL_CONTENT);
|
||
let b = res.into_body().collect().await.unwrap().to_bytes();
|
||
assert_eq!(b.len(), 188);
|
||
assert_eq!(b[0], 0x47);
|
||
|
||
// settings: validation
|
||
let mut s = json_of(&env.lan, Method::GET, "/api/settings", &c, None).await;
|
||
s["hls_window"] = json!(1);
|
||
let (st, _) = call(&env.lan, Method::PUT, "/api/settings", &c, Some(s.clone())).await;
|
||
assert_eq!(st, StatusCode::BAD_REQUEST);
|
||
s["hls_window"] = json!(10);
|
||
s["stream_open_cidrs"] = json!([]);
|
||
json_of(&env.lan, Method::PUT, "/api/settings", &c, Some(s)).await;
|
||
// LAN without a token is no longer open, but a panel session is enough
|
||
let (st, _) = call(&env.lan, Method::GET, "/playlist.m3u", "", None).await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
let (st, _) = call(&env.lan, Method::GET, "/playlist.m3u", &c, None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
|
||
// series recording rule: matches upcoming “TVN - audycja N” programmes from EIT
|
||
let rule = json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/autorec",
|
||
&c,
|
||
Some(json!({"name": "TVN", "pattern": "^TVN - audycja [2-4]$"})),
|
||
)
|
||
.await;
|
||
assert!(rule["scheduled"].as_u64().unwrap() >= 1, "{rule}");
|
||
let recs = json_of(&env.lan, Method::GET, "/api/recordings", &c, None).await;
|
||
assert!(recs
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|r| r["autorec_id"] == rule["id"] && r["status"] == "scheduled"));
|
||
// running it again does not create duplicates
|
||
let again = simply_dvb::recorder::run_autorec(&env.state).await.unwrap();
|
||
assert_eq!(again.0, 0);
|
||
json_of(
|
||
&env.lan,
|
||
Method::DELETE,
|
||
&format!("/api/autorec/{}", rule["id"]),
|
||
&c,
|
||
None,
|
||
)
|
||
.await;
|
||
|
||
// Prometheus metrics
|
||
let (st, body) = call(&env.lan, Method::GET, "/metrics", &c, None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let m = String::from_utf8(body).unwrap();
|
||
assert!(
|
||
m.contains("simply_dvb_tuner_locked{adapter=\"virtual0\""),
|
||
"{m}"
|
||
);
|
||
assert!(m.contains("simply_dvb_channels{enabled=\"true\"}"));
|
||
let (st, _) = call(&env.wan, Method::GET, "/metrics", "", None).await;
|
||
assert_eq!(st, StatusCode::UNAUTHORIZED);
|
||
|
||
// backup and restore
|
||
let (st, backup) = call(&env.lan, Method::GET, "/api/backup", &c, None).await;
|
||
assert_eq!(st, StatusCode::OK);
|
||
let backup: Value = serde_json::from_slice(&backup).unwrap();
|
||
assert_eq!(backup["channels"].as_array().unwrap().len(), 4);
|
||
json_of(
|
||
&env.lan,
|
||
Method::DELETE,
|
||
&format!("/api/channels/{id1}"),
|
||
&c,
|
||
None,
|
||
)
|
||
.await;
|
||
let r = json_of(&env.lan, Method::POST, "/api/restore", &c, Some(backup)).await;
|
||
assert_eq!(r["channels"], 4);
|
||
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
|
||
assert_eq!(chans.as_array().unwrap().len(), 4);
|
||
|
||
env.state.tuners.shutdown();
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||
async fn xmltv_import_maps_channels() {
|
||
let env = setup().await;
|
||
let c = env.cookie.clone();
|
||
let db = &env.state.db;
|
||
let ch = db.create_channel(1, "TVP 1", None, "TV").await.unwrap();
|
||
db.create_channel(2, "Other channel", None, "TV")
|
||
.await
|
||
.unwrap();
|
||
let xml = r#"<tv><channel id="TVP1.pl"><display-name>TVP1</display-name></channel>
|
||
<programme start="20990101060000 +0100" stop="20990101070000 +0100" channel="TVP1.pl"><title>Teleexpress</title><desc>Wiadomości</desc></programme>
|
||
<programme start="20990101070000 +0100" stop="20990101080000 +0100" channel="Nieznany"><title>X</title></programme></tv>"#;
|
||
let (matched, n) = epg::import_xml(&env.state, xml).await.unwrap();
|
||
assert_eq!((matched, n), (1, 1));
|
||
let ev = json_of(
|
||
&env.lan,
|
||
Method::GET,
|
||
&format!("/api/epg?channel={ch}&from=4070900000&to=4071000000"),
|
||
&c,
|
||
None,
|
||
)
|
||
.await;
|
||
assert_eq!(ev[0]["title"], "Teleexpress");
|
||
assert_eq!(ev[0]["source"], "xmltv");
|
||
}
|
||
|
||
fn base64_encode(s: &str) -> String {
|
||
use base64::Engine;
|
||
base64::engine::general_purpose::STANDARD.encode(s)
|
||
}
|
||
|
||
/// HTSP client side of the wire format (enough for the test).
|
||
mod htsp_client {
|
||
pub use simply_dvb::htsp::msg::{Msg, Val};
|
||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||
use tokio::net::TcpStream;
|
||
|
||
pub async fn send(s: &mut TcpStream, m: Msg) {
|
||
s.write_all(&m.encode()).await.unwrap();
|
||
}
|
||
pub async fn recv(s: &mut TcpStream) -> Msg {
|
||
let mut l = [0u8; 4];
|
||
s.read_exact(&mut l).await.unwrap();
|
||
let mut b = vec![0u8; u32::from_be_bytes(l) as usize];
|
||
s.read_exact(&mut b).await.unwrap();
|
||
Msg::decode(&b).unwrap()
|
||
}
|
||
/// Sends a request and returns its reply (async messages are collected into `seen`).
|
||
pub async fn call(s: &mut TcpStream, seq: i64, m: Msg, seen: &mut Vec<Msg>) -> Msg {
|
||
send(s, m.int("seq", seq)).await;
|
||
loop {
|
||
let r = recv(s).await;
|
||
if r.get_i64("seq") == Some(seq) {
|
||
return r;
|
||
}
|
||
seen.push(r);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
||
async fn htsp_protocol() {
|
||
use htsp_client::*;
|
||
let env = setup().await;
|
||
let c = env.cookie.clone();
|
||
json_of(
|
||
&env.lan,
|
||
Method::POST,
|
||
"/api/scan",
|
||
&c,
|
||
Some(json!({"preset": "custom", "frequencies_mhz": [538], "follow_nit": false})),
|
||
)
|
||
.await;
|
||
for _ in 0..100 {
|
||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||
let s = json_of(&env.lan, Method::GET, "/api/scan", &c, None).await;
|
||
if !s["running"].as_bool().unwrap() {
|
||
break;
|
||
}
|
||
}
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||
let addr = listener.local_addr().unwrap();
|
||
let (_stop_tx, stop_rx) = tokio::sync::watch::channel(false);
|
||
tokio::spawn(simply_dvb::htsp::serve(
|
||
env.state.clone(),
|
||
listener,
|
||
stop_rx,
|
||
));
|
||
|
||
let mut s = tokio::net::TcpStream::connect(addr).await.unwrap();
|
||
let mut seen = Vec::new();
|
||
let hello = call(
|
||
&mut s,
|
||
1,
|
||
Msg::method("hello")
|
||
.int("htspversion", 34)
|
||
.str("clientname", "Kodi")
|
||
.str("clientversion", "21"),
|
||
&mut seen,
|
||
)
|
||
.await;
|
||
assert_eq!(hello.get_i64("htspversion"), Some(34));
|
||
assert_eq!(hello.get_bin("challenge").unwrap().len(), 32);
|
||
// 127.0.0.1 is in the default open networks: no credentials needed
|
||
let auth = call(&mut s, 2, Msg::method("authenticate"), &mut seen).await;
|
||
assert!(auth.get("noaccess").is_none(), "{auth:?}");
|
||
|
||
call(
|
||
&mut s,
|
||
3,
|
||
Msg::method("enableAsyncMetadata").int("epg", 1),
|
||
&mut seen,
|
||
)
|
||
.await;
|
||
loop {
|
||
let m = recv(&mut s).await;
|
||
let done = m.get_str("method") == Some("initialSyncCompleted");
|
||
seen.push(m);
|
||
if done {
|
||
break;
|
||
}
|
||
}
|
||
let channels: Vec<&Msg> = seen
|
||
.iter()
|
||
.filter(|m| m.get_str("method") == Some("channelAdd"))
|
||
.collect();
|
||
assert_eq!(channels.len(), 3, "{seen:?}");
|
||
assert_eq!(channels[0].get_str("channelName"), Some("TVP1 HD"));
|
||
assert!(seen.iter().any(|m| m.get_str("method") == Some("tagAdd")));
|
||
let ch = channels[0].get_i64("channelId").unwrap();
|
||
|
||
call(
|
||
&mut s,
|
||
4,
|
||
Msg::method("subscribe")
|
||
.int("subscriptionId", 9)
|
||
.int("channelId", ch),
|
||
&mut seen,
|
||
)
|
||
.await;
|
||
let mut started = false;
|
||
let mut video = 0;
|
||
let mut audio = 0;
|
||
let mut first_key = None;
|
||
let deadline = tokio::time::Instant::now() + Duration::from_secs(15);
|
||
while tokio::time::Instant::now() < deadline && (video < 20 || audio < 20) {
|
||
let m = tokio::time::timeout(Duration::from_secs(5), recv(&mut s))
|
||
.await
|
||
.expect("no HTSP data");
|
||
match m.get_str("method") {
|
||
Some("subscriptionStart") => {
|
||
let Some(Val::List(streams)) = m.get("streams") else {
|
||
panic!("no streams")
|
||
};
|
||
assert!(streams.len() >= 2);
|
||
started = true;
|
||
}
|
||
Some("muxpkt") => {
|
||
assert!(started, "muxpkt before subscriptionStart");
|
||
assert!(!m.get_bin("payload").unwrap().is_empty());
|
||
if m.get_i64("stream") == Some(1) {
|
||
first_key.get_or_insert(m.get_i64("frametype").unwrap());
|
||
video += 1;
|
||
} else {
|
||
audio += 1;
|
||
}
|
||
}
|
||
Some("subscriptionStop") => panic!("stopped: {m:?}"),
|
||
_ => {}
|
||
}
|
||
}
|
||
assert!(video >= 20 && audio >= 20, "video {video} audio {audio}");
|
||
// the stream starts with a keyframe
|
||
assert_eq!(first_key, Some('I' as i64));
|
||
let r = call(
|
||
&mut s,
|
||
5,
|
||
Msg::method("unsubscribe").int("subscriptionId", 9),
|
||
&mut seen,
|
||
)
|
||
.await;
|
||
assert!(r.get("error").is_none());
|
||
}
|