Files
simply-dvb/src/app.rs
T
Mateusz Gruszczyński 9e65aa0103
build / test (push) Waiting to run
0.1.17
2026-11-17 16:50:28 +01:00

276 lines
10 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Application state shared by the web server and background tasks.
use crate::clients::Clients;
use crate::db::Db;
use crate::dvb::{self, AdapterInfo, DeliverySystem};
use crate::hls::HlsManager;
use crate::scanjob::ScanState;
use crate::settings::Settings;
use crate::ts::si::EpgItem;
use crate::tuner::TunerManager;
use anyhow::Result;
use std::collections::HashMap;
use std::net::IpAddr;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant};
use tokio::sync::{mpsc, Notify};
pub type State = Arc<AppState>;
#[derive(Debug, Clone)]
pub struct Options {
pub data_dir: PathBuf,
pub dev_root: String,
pub virtual_dirs: Vec<String>,
/// Stream port (tvheadend-compatible), if enabled.
pub stream_port: Option<u16>,
/// HTSP port, if enabled.
pub htsp_port: Option<u16>,
/// Panel port (for links such as the TV pairing page).
pub panel_port: u16,
}
#[derive(Default, Clone, serde::Serialize)]
pub struct EpgStatus {
pub last_grab: Option<i64>,
pub grabbing_mux: Option<i64>,
pub last_xmltv: Option<i64>,
pub xmltv_result: String,
pub ota_events_written: u64,
}
pub struct AppState {
pub db: Db,
pub settings: RwLock<Settings>,
pub opts: Options,
pub tuners: Arc<TunerManager>,
pub hls: HlsManager,
pub clients: Arc<Clients>,
pub scan: ScanState,
pub started: Instant,
pub http: reqwest::Client,
pub login_failures: Mutex<HashMap<IpAddr, (u32, Instant)>>,
pub recordings_running: Mutex<HashMap<i64, Arc<AtomicBool>>>,
pub epg_status: Mutex<EpgStatus>,
pub epg_wakeup: Notify,
pub xmltv_wakeup: Notify,
pub rec_wakeup: Notify,
/// Bumped whenever any change is committed to the database (see `db::watch_changes`).
pub db_changed: tokio::sync::watch::Sender<u64>,
pub shutting_down: AtomicBool,
pub stats: crate::stats::Stats,
/// The separate stream port is bound (it may wait for tvheadend to release it).
pub stream_port_active: AtomicBool,
pub htsp_port_active: AtomicBool,
pub icon_job: Mutex<crate::icons::IconJob>,
/// `ffmpeg -version` first line, or None when ffmpeg is not available.
pub ffmpeg: Mutex<Option<String>>,
/// Wakes the ACL host-name resolver (settings/tokens changed).
pub acl_refresh: Notify,
/// A stream detection (probe) of channels without known streams is running.
pub probing: AtomicBool,
/// Antenna meter: muxes kept tuned until the given time (mux id → deadline).
pub signal_hold: Mutex<HashMap<i64, std::time::Instant>>,
}
impl AppState {
pub async fn new(
db: Db,
opts: Options,
) -> Result<(State, mpsc::UnboundedReceiver<(i64, Vec<EpgItem>)>)> {
let mut settings: Settings = match db.get_setting("config").await? {
Some(s) => serde_json::from_str(&s).unwrap_or_default(),
None => Settings::default(),
};
// default server name from before the project was renamed
if settings.server_name == "simple-dvbt" {
settings.server_name = "simply-dvb".into();
}
let (epg_tx, epg_rx) = mpsc::unbounded_channel();
let tuners = TunerManager::new(epg_tx);
let (pmt_tx, mut pmt_rx) = mpsc::unbounded_channel::<(i64, Vec<crate::ts::tables::Pmt>)>();
*tuners.pmt_tx.lock().unwrap() = Some(pmt_tx);
{
let db = db.clone();
tokio::spawn(async move {
while let Some((mux_id, pmts)) = pmt_rx.recv().await {
for p in pmts {
match db.update_service_pmt(mux_id, &p).await {
Ok(true) => tracing::info!(
"service {} on mux {mux_id}: streams updated from PMT ({})",
p.program,
p.streams
.iter()
.map(|s| s.kind.label())
.collect::<Vec<_>>()
.join(", ")
),
Ok(false) => {}
Err(e) => tracing::warn!("updating service streams: {e:#}"),
}
}
}
});
}
tuners
.epg_enabled
.store(settings.epg_ota_enabled, Ordering::Relaxed);
*tuners.linger.lock().unwrap() = Duration::from_secs(settings.tuner_linger_seconds as u64);
tuners
.pid_filter
.store(settings.tuner_pid_filter, Ordering::Relaxed);
let http = reqwest::Client::builder()
.user_agent(concat!("simply-dvb/", env!("CARGO_PKG_VERSION")))
.timeout(Duration::from_secs(120))
.connect_timeout(Duration::from_secs(15))
.build()?;
let state = Arc::new(AppState {
db,
settings: RwLock::new(settings),
opts,
tuners,
hls: HlsManager::default(),
clients: Arc::new(Clients::default()),
scan: ScanState::default(),
started: Instant::now(),
http,
login_failures: Mutex::new(HashMap::new()),
recordings_running: Mutex::new(HashMap::new()),
epg_status: Mutex::new(EpgStatus::default()),
epg_wakeup: Notify::new(),
xmltv_wakeup: Notify::new(),
rec_wakeup: Notify::new(),
db_changed: tokio::sync::watch::channel(0).0,
shutting_down: AtomicBool::new(false),
stats: crate::stats::Stats::default(),
stream_port_active: AtomicBool::new(false),
htsp_port_active: AtomicBool::new(false),
icon_job: Mutex::new(crate::icons::IconJob::default()),
ffmpeg: Mutex::new(None),
acl_refresh: Notify::new(),
probing: AtomicBool::new(false),
signal_hold: Mutex::new(HashMap::new()),
});
state.detect_ffmpeg().await;
state.refresh_adapters().await?;
Ok((state, epg_rx))
}
/// Checks whether the configured ffmpeg can be started (transcoding profiles need it).
pub async fn detect_ffmpeg(&self) {
let path = self.settings().ffmpeg_path;
let out = tokio::process::Command::new(&path)
.arg("-version")
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.await;
let v = match out {
Ok(o) if o.status.success() => String::from_utf8_lossy(&o.stdout)
.lines()
.next()
.map(|l| l.chars().take(120).collect()),
_ => None,
};
match &v {
Some(v) => tracing::info!("ffmpeg: {v}"),
None => tracing::warn!(
"ffmpeg not found ({path}) – browser transcoding profiles (aac, h264) are unavailable"
),
}
*self.ffmpeg.lock().unwrap() = v;
}
pub fn has_ffmpeg(&self) -> bool {
self.ffmpeg.lock().unwrap().is_some()
}
pub fn settings(&self) -> Settings {
self.settings.read().unwrap().clone()
}
pub async fn save_settings(&self, s: Settings) -> Result<()> {
self.db
.set_setting("config", &serde_json::to_string(&s)?)
.await?;
self.apply_settings(s).await;
Ok(())
}
/// Picks up settings changed in the database by the command line tool
/// (`simply-dvb settings set …`, `access reset-panel`) – checked every few seconds.
pub async fn settings_watch(self: Arc<Self>) {
loop {
tokio::time::sleep(Duration::from_secs(3)).await;
let Ok(Some(raw)) = self.db.get_setting("config").await else {
continue;
};
let Ok(mut s) = serde_json::from_str::<Settings>(&raw) else {
continue;
};
if s.validate().is_err() || s == self.settings() {
continue;
}
tracing::info!("settings changed outside the panel (command line) – applied");
self.apply_settings(s).await;
}
}
async fn apply_settings(&self, s: Settings) {
self.tuners
.epg_enabled
.store(s.epg_ota_enabled, Ordering::Relaxed);
*self.tuners.linger.lock().unwrap() = Duration::from_secs(s.tuner_linger_seconds as u64);
self.tuners
.pid_filter
.store(s.tuner_pid_filter, Ordering::Relaxed);
let ffmpeg_changed = self.settings.read().unwrap().ffmpeg_path != s.ffmpeg_path;
*self.settings.write().unwrap() = s;
self.acl_refresh.notify_one();
if ffmpeg_changed {
self.detect_ffmpeg().await;
}
}
/// Discovers adapters (Linux DVB + virtual) and updates the tuner manager.
pub async fn refresh_adapters(&self) -> Result<Vec<AdapterInfo>> {
let dev_root = self.opts.dev_root.clone();
let mut found = tokio::task::spawn_blocking(move || dvb::discover(&dev_root)).await?;
for (i, dir) in self.opts.virtual_dirs.iter().enumerate() {
found.push(AdapterInfo {
id: format!("virtual{i}"),
name: format!("Virtual adapter ({dir})"),
kind: "virtual".into(),
path: dir.clone(),
delivery_systems: vec![
DeliverySystem::Dvbt,
DeliverySystem::Dvbt2,
DeliverySystem::Dvbc,
],
});
}
let mut list = Vec::new();
for a in &found {
let (en, prio) = self.db.adapter_config(&a.id).await?;
list.push((a.clone(), en, prio));
}
self.tuners.set_adapters(list);
Ok(found)
}
pub fn data_path(&self, name: &str) -> PathBuf {
self.opts.data_dir.join(name)
}
pub fn recordings_dir(&self) -> PathBuf {
let s = self.settings();
if s.recordings_dir.trim().is_empty() {
self.data_path("recordings")
} else {
PathBuf::from(s.recordings_dir.trim())
}
}
}