291 lines
9.2 KiB
Rust
291 lines
9.2 KiB
Rust
//! Registry of active stream clients (TS, HLS, recordings) shown in the panel.
|
|
|
|
use crate::db::now;
|
|
use serde::Serialize;
|
|
use std::collections::HashMap;
|
|
use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
#[derive(Serialize)]
|
|
pub struct ClientEntry {
|
|
pub id: u64,
|
|
pub kind: String,
|
|
pub channel_id: i64,
|
|
pub channel_name: String,
|
|
pub ip: String,
|
|
pub user_agent: String,
|
|
pub who: String,
|
|
pub profile: String,
|
|
pub started: i64,
|
|
pub bytes: AtomicU64,
|
|
pub last_seen: AtomicI64,
|
|
#[serde(skip)]
|
|
key: String,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct Clients {
|
|
map: Mutex<HashMap<u64, Arc<ClientEntry>>>,
|
|
next: AtomicU64,
|
|
/// Total bytes sent to stream clients since start (for throughput charts).
|
|
sent: AtomicU64,
|
|
/// Total bytes written by recordings since start.
|
|
recorded: AtomicU64,
|
|
/// Bytes sent per protocol: MPEG-TS over HTTP, HLS, HTSP.
|
|
sent_ts: AtomicU64,
|
|
sent_hls: AtomicU64,
|
|
sent_htsp: AtomicU64,
|
|
/// Finished viewing sessions go here (written to the watch history).
|
|
history: Mutex<Option<tokio::sync::mpsc::UnboundedSender<crate::db::WatchRecord>>>,
|
|
}
|
|
|
|
pub struct ClientGuard {
|
|
clients: Arc<ClientEntry>,
|
|
owner: Arc<Clients>,
|
|
}
|
|
|
|
impl ClientGuard {
|
|
pub fn add_bytes(&self, n: u64) {
|
|
self.clients.bytes.fetch_add(n, Ordering::Relaxed);
|
|
self.owner.count(&self.clients.kind, n);
|
|
self.clients.last_seen.store(now(), Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
impl Drop for ClientGuard {
|
|
fn drop(&mut self) {
|
|
self.owner.map.lock().unwrap().remove(&self.clients.id);
|
|
let c = &self.clients;
|
|
let ended = now();
|
|
// sessions shorter than 10 s are channel zapping / probes, not viewing
|
|
if c.kind != "recording" && ended - c.started >= 10 {
|
|
if let Some(tx) = self.owner.history.lock().unwrap().as_ref() {
|
|
let _ = tx.send(crate::db::WatchRecord {
|
|
channel_id: Some(c.channel_id).filter(|id| *id > 0),
|
|
channel_name: c.channel_name.clone(),
|
|
kind: c.kind.clone(),
|
|
who: c.who.clone(),
|
|
ip: c.ip.clone(),
|
|
device: device_name(&c.user_agent),
|
|
started: c.started,
|
|
ended,
|
|
bytes: c.bytes.load(Ordering::Relaxed) as i64,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct NewClient<'a> {
|
|
pub kind: &'a str,
|
|
pub channel_id: i64,
|
|
pub channel_name: &'a str,
|
|
pub ip: &'a str,
|
|
pub user_agent: &'a str,
|
|
pub who: &'a str,
|
|
pub profile: &'a str,
|
|
}
|
|
|
|
impl Clients {
|
|
/// Enables the watch history (finished sessions are sent to `tx`).
|
|
pub fn set_history(&self, tx: tokio::sync::mpsc::UnboundedSender<crate::db::WatchRecord>) {
|
|
*self.history.lock().unwrap() = Some(tx);
|
|
}
|
|
|
|
fn count(&self, kind: &str, n: u64) {
|
|
if kind == "recording" {
|
|
self.recorded.fetch_add(n, Ordering::Relaxed);
|
|
} else {
|
|
self.sent.fetch_add(n, Ordering::Relaxed);
|
|
match kind {
|
|
"hls" => &self.sent_hls,
|
|
"htsp" => &self.sent_htsp,
|
|
_ => &self.sent_ts,
|
|
}
|
|
.fetch_add(n, Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
/// Bytes sent since start per protocol: (TS over HTTP, HLS, HTSP).
|
|
pub fn by_protocol(&self) -> (u64, u64, u64) {
|
|
(
|
|
self.sent_ts.load(Ordering::Relaxed),
|
|
self.sent_hls.load(Ordering::Relaxed),
|
|
self.sent_htsp.load(Ordering::Relaxed),
|
|
)
|
|
}
|
|
|
|
/// (bytes sent to clients, bytes recorded) since start.
|
|
pub fn totals(&self) -> (u64, u64) {
|
|
(
|
|
self.sent.load(Ordering::Relaxed),
|
|
self.recorded.load(Ordering::Relaxed),
|
|
)
|
|
}
|
|
|
|
fn make(&self, c: &NewClient, key: String) -> Arc<ClientEntry> {
|
|
let id = self.next.fetch_add(1, Ordering::Relaxed) + 1;
|
|
Arc::new(ClientEntry {
|
|
id,
|
|
kind: c.kind.into(),
|
|
channel_id: c.channel_id,
|
|
channel_name: c.channel_name.into(),
|
|
ip: c.ip.into(),
|
|
user_agent: c.user_agent.chars().take(160).collect(),
|
|
who: c.who.into(),
|
|
profile: c.profile.into(),
|
|
started: now(),
|
|
bytes: AtomicU64::new(0),
|
|
last_seen: AtomicI64::new(now()),
|
|
key,
|
|
})
|
|
}
|
|
|
|
/// Client whose lifetime is bound to a guard (TS, recording).
|
|
pub fn register(self: &Arc<Self>, c: NewClient) -> ClientGuard {
|
|
let e = self.make(&c, String::new());
|
|
self.map.lock().unwrap().insert(e.id, e.clone());
|
|
ClientGuard {
|
|
clients: e,
|
|
owner: self.clone(),
|
|
}
|
|
}
|
|
|
|
/// HLS client identified by (channel, profile, IP, UA); expires when idle.
|
|
pub fn touch_hls(&self, c: NewClient, bytes: u64) {
|
|
let key = format!("{}|{}|{}|{}", c.channel_id, c.profile, c.ip, c.user_agent);
|
|
self.sent.fetch_add(bytes, Ordering::Relaxed);
|
|
let mut map = self.map.lock().unwrap();
|
|
if let Some(e) = map.values().find(|e| e.kind == "hls" && e.key == key) {
|
|
e.bytes.fetch_add(bytes, Ordering::Relaxed);
|
|
e.last_seen.store(now(), Ordering::Relaxed);
|
|
return;
|
|
}
|
|
let e = self.make(&c, key);
|
|
e.bytes.fetch_add(bytes, Ordering::Relaxed);
|
|
map.insert(e.id, e);
|
|
}
|
|
|
|
pub fn reap(&self, hls_idle: i64) {
|
|
let t = now();
|
|
self.map
|
|
.lock()
|
|
.unwrap()
|
|
.retain(|_, e| e.kind != "hls" || t - e.last_seen.load(Ordering::Relaxed) <= hls_idle);
|
|
}
|
|
|
|
pub fn list(&self) -> Vec<Arc<ClientEntry>> {
|
|
let mut v: Vec<_> = self.map.lock().unwrap().values().cloned().collect();
|
|
v.sort_by_key(|e| e.started);
|
|
v
|
|
}
|
|
}
|
|
|
|
/// Friendly device/app name derived from a User-Agent (or HTSP client name).
|
|
pub fn device_name(ua: &str) -> String {
|
|
let u = ua.trim();
|
|
if u.is_empty() {
|
|
return "unknown".into();
|
|
}
|
|
let l = u.to_lowercase();
|
|
let pick = |name: &str| -> String {
|
|
// version after the product name when present ("Kodi/21.0", "VLC/3.0.20")
|
|
let ver = l
|
|
.find(&name.to_lowercase())
|
|
.map(|i| &u[i + name.len()..])
|
|
.and_then(|rest| {
|
|
let rest = rest.trim_start_matches(['/', ' ']);
|
|
let v: String = rest
|
|
.chars()
|
|
.take_while(|c| c.is_ascii_digit() || *c == '.')
|
|
.collect();
|
|
(!v.is_empty()).then_some(v)
|
|
});
|
|
match ver {
|
|
Some(v) => format!("{name} {v}"),
|
|
None => name.to_string(),
|
|
}
|
|
};
|
|
let apps = [
|
|
("kodi", "Kodi"),
|
|
("tivimate", "TiviMate"),
|
|
("ott navigator", "OTT Navigator"),
|
|
("iptv smarters", "IPTV Smarters"),
|
|
("tvhclient", "TVHClient"),
|
|
("vlc", "VLC"),
|
|
("mpv", "mpv"),
|
|
("ffmpeg", "ffmpeg"),
|
|
("lavf", "ffmpeg"),
|
|
("exoplayer", "ExoPlayer"),
|
|
("stagefright", "Android media player"),
|
|
("bravia", "Sony Bravia"),
|
|
("smarttv", "Smart TV"),
|
|
("tizen", "Samsung Tizen"),
|
|
("web0s", "LG webOS"),
|
|
("roku", "Roku"),
|
|
("appletv", "Apple TV"),
|
|
("gstreamer", "GStreamer"),
|
|
("plex", "Plex"),
|
|
("jellyfin", "Jellyfin"),
|
|
("emby", "Emby"),
|
|
("curl", "curl"),
|
|
("wget", "wget"),
|
|
("python", "Python"),
|
|
("okhttp", "Android app"),
|
|
("dalvik", "Android app"),
|
|
("cfnetwork", "iOS/macOS app"),
|
|
];
|
|
for (needle, name) in apps {
|
|
if l.contains(needle) {
|
|
return pick(name);
|
|
}
|
|
}
|
|
if l.contains("mozilla") || l.contains("safari") || l.contains("firefox") {
|
|
let browser = if l.contains("edg/") {
|
|
"Edge"
|
|
} else if l.contains("opr/") {
|
|
"Opera"
|
|
} else if l.contains("firefox") {
|
|
"Firefox"
|
|
} else if l.contains("chrome") || l.contains("crios") {
|
|
"Chrome"
|
|
} else if l.contains("safari") {
|
|
"Safari"
|
|
} else {
|
|
"browser"
|
|
};
|
|
let os = if l.contains("android") {
|
|
" · Android"
|
|
} else if l.contains("iphone") || l.contains("ipad") {
|
|
" · iOS"
|
|
} else if l.contains("windows") {
|
|
" · Windows"
|
|
} else if l.contains("mac os") {
|
|
" · macOS"
|
|
} else if l.contains("linux") {
|
|
" · Linux"
|
|
} else {
|
|
""
|
|
};
|
|
return format!("{browser}{os}");
|
|
}
|
|
u.split(['/', ' ', '(']).next().unwrap_or(u).to_string()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn device_names() {
|
|
assert_eq!(device_name("Kodi/21.0 (Linux; Android 12)"), "Kodi 21.0");
|
|
assert_eq!(device_name("VLC/3.0.20 LibVLC/3.0.20"), "VLC 3.0.20");
|
|
assert!(device_name("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36").starts_with("Chrome"));
|
|
assert_eq!(
|
|
device_name("Dalvik/2.1.0 (Linux; U; Android 10; BRAVIA 4K UR2 Build/QTG2.200305.002)"),
|
|
"Sony Bravia"
|
|
);
|
|
assert_eq!(device_name(""), "unknown");
|
|
}
|
|
}
|