use std::io::Write;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use anyhow::{bail, Context, Result};
use crate::app::App;
static STOP: AtomicBool = AtomicBool::new(false);
extern "C" fn on_signal(_: libc::c_int) {
STOP.store(true, Ordering::SeqCst);
}
pub struct WatchOpts {
pub interval: Duration,
pub duration: Option<Duration>,
pub out: Option<PathBuf>,
pub stop: Option<PathBuf>,
pub proc: Option<String>,
}
pub fn parse_duration(s: &str) -> Option<Duration> {
let s = s.trim();
let (num, unit) = s.split_at(s.find(|c: char| c.is_ascii_alphabetic()).unwrap_or(s.len()));
let n: u64 = num.parse().ok()?;
let secs = match unit {
"" | "s" => n,
"m" => n * 60,
"h" => n * 3600,
_ => return None,
};
Some(Duration::from_secs(secs))
}
pub fn run(args: &[String]) -> Result<()> {
let zh = crate::cli_lang_zh();
let p = |en: &str, c: &str| crate::pick_s(zh, en, c);
let mut opts = WatchOpts {
interval: Duration::from_secs(5),
duration: None,
out: None,
stop: None,
proc: None,
};
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"-h" | "--help" => {
println!("{}", watch_usage(zh));
return Ok(());
}
"--interval" => {
let v = args
.get(i + 1)
.context(p("--interval needs a value (seconds)", "--interval 需要一个秒数"))?;
let n: u64 = v.parse().map_err(|_| {
anyhow::anyhow!(p(
&format!("--interval {v:?} is not a number"),
&format!("--interval {v:?} 不是秒数")
))
})?;
opts.interval = Duration::from_secs(n.max(1));
i += 1;
}
"--duration" => {
let v = args.get(i + 1).context(p(
"--duration needs a value (e.g. 30s/5m/2h)",
"--duration 需要一个时长(如 30s/5m/2h)",
))?;
opts.duration = Some(parse_duration(v).ok_or_else(|| {
anyhow::anyhow!(p(
&format!("--duration {v:?} is not parseable"),
&format!("--duration {v:?} 无法解析")
))
})?);
i += 1;
}
"--out" | "--stop" | "--proc" => {
let v = args.get(i + 1).context(format!(
"{},{}",
args[i],
p("needs a value", "需要一个值")
))?;
match args[i].as_str() {
"--out" => opts.out = Some(PathBuf::from(v)),
"--stop" => opts.stop = Some(PathBuf::from(v)),
_ => opts.proc = Some(v.clone()),
}
i += 1;
}
a if a.starts_with("--") => bail!("ltop watch: unknown option {a} (try --help)"),
a => bail!(
"{}",
p(
&format!("ltop watch: unexpected argument {a:?} (subcommand takes options only; try --help)"),
&format!("ltop watch: 意外参数 {a:?}(子命令只收选项,try --help)")
)
),
}
i += 1;
}
execute(opts, zh)?;
Ok(())
}
fn watch_usage(zh: bool) -> String {
if zh {
format!(
"ltop watch v{} — headless 采集,schema v1 JSONL(AI/ltop report 的输入)
USAGE:
ltop watch [OPTIONS]
--interval <S> 采样间隔,秒(默认 5)
--duration <T> 总时长,如 30s / 5m / 2h(缺省 = 采到 --stop 或 Ctrl-C)
--out <FILE> 输出 JSONL(默认 ~/.local/state/ltop/ltop-session-<ts>.jsonl)
--stop <FILE> 哨兵文件:文件出现即停止(停止后删除该文件)
--proc <NAME> 聚焦:只写名称匹配(子串)的进程及其连接;按名追踪,
进程重启换 pid 不丢线
-h, --help 本帮助
消费:ltop report <file>(摘要)/ jq(任意查询);TUI monlog(ltop-log-*)
同 schema,report 也能读。",
env!("CARGO_PKG_VERSION")
)
} else {
format!(
"ltop watch v{} — headless capture to schema-v1 JSONL (input for ltop report / AI)
USAGE:
ltop watch [OPTIONS]
--interval <S> sampling interval, seconds (default 5)
--duration <T> total duration, e.g. 30s / 5m / 2h (default: run until --stop or Ctrl-C)
--out <FILE> output JSONL (default ~/.local/state/ltop/ltop-session-<ts>.jsonl)
--stop <FILE> sentinel file: stop as soon as it appears (consumed on stop)
--proc <NAME> focus: record only processes matching NAME (substring) and their
connections; tracked by name — survives pid changes on restart
-h, --help this help
Consume: ltop report <file> (summary) / jq (arbitrary queries); TUI monitoring
logs (ltop-log-*) share the same schema — report reads them too.",
env!("CARGO_PKG_VERSION")
)
}
}
fn default_out() -> PathBuf {
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
crate::log::log_dir().join(format!("ltop-session-{secs}.jsonl"))
}
fn proc_matches(filter: &Option<String>, name: &str) -> bool {
match filter {
None => true,
Some(f) => name.to_lowercase().contains(&f.to_lowercase()),
}
}
fn execute(opts: WatchOpts, zh: bool) -> Result<usize> {
let p = |en: &str, c: &str| crate::pick_s(zh, en, c);
unsafe {
libc::signal(
libc::SIGINT,
on_signal as extern "C" fn(libc::c_int) as libc::sighandler_t,
);
libc::signal(
libc::SIGTERM,
on_signal as extern "C" fn(libc::c_int) as libc::sighandler_t,
);
}
let mut app = App::new(None);
app.update();
std::thread::sleep(opts.interval.min(Duration::from_millis(1200)));
app.update();
let start = Instant::now();
let path = opts.out.clone().unwrap_or_else(default_out);
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).with_context(|| {
p(
&format!("cannot create output directory {}", dir.display()),
&format!("建输出目录失败 {}", dir.display()),
)
})?;
}
let mut f = std::fs::File::create(&path).with_context(|| {
p(
&format!("cannot create {}", path.display()),
&format!("创建 {} 失败", path.display()),
)
})?;
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let proc_js = opts
.proc
.as_deref()
.map(|p| format!("\"{}\"", crate::log::json_str(p)))
.unwrap_or_else(|| "null".into());
let dur_js = opts
.duration
.map(|d| d.as_secs().to_string())
.unwrap_or_else(|| "null".into());
writeln!(
f,
"{{\"watch_start\":{secs},\"host\":\"{}\",\"interval_s\":{},\"proc\":{proc_js},\"duration_s\":{dur_js}}}",
crate::log::json_str(&app.hostname),
opts.interval.as_secs(),
)?;
let mut lines = 0usize;
let mut reason = p("duration reached", "duration 到点");
loop {
let mut snap = crate::snapshot::from_app(&app);
if opts.proc.is_some() {
let f = &opts.proc;
snap.procs.retain(|p| proc_matches(f, &p.name));
snap.conns
.retain(|c| c.process.as_deref().is_some_and(|pn| proc_matches(f, pn)));
}
writeln!(f, "{}", serde_json::to_string(&snap).unwrap_or_default())?;
lines += 1;
if STOP.load(Ordering::SeqCst) {
reason = p("SIGINT/SIGTERM received", "收到 SIGINT/SIGTERM");
break;
}
if let Some(sf) = &opts.stop {
if sf.exists() {
let _ = std::fs::remove_file(sf);
reason = p("stop file seen", "哨兵文件出现");
break;
}
}
if let Some(d) = opts.duration {
if start.elapsed() >= d {
break;
}
}
let budget = opts
.duration
.map(|d| d.saturating_sub(start.elapsed()))
.unwrap_or(opts.interval)
.min(opts.interval);
let mut left = budget;
while left > Duration::ZERO && !STOP.load(Ordering::SeqCst) {
let slice = left.min(Duration::from_millis(200));
std::thread::sleep(slice);
left = left.saturating_sub(slice);
}
app.update();
}
f.flush()?;
eprintln!(
"{}",
p(
&format!(
"ltop watch: {} ({reason}), {lines} snapshots → {}",
crate::app::fmt_dur(start.elapsed().as_secs()),
path.display()
),
&format!(
"ltop watch: {}({reason}),{lines} 行快照 → {}",
crate::app::fmt_dur(start.elapsed().as_secs()),
path.display()
)
)
);
Ok(lines)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_durations() {
assert_eq!(parse_duration("10s"), Some(Duration::from_secs(10)));
assert_eq!(parse_duration("90"), Some(Duration::from_secs(90)));
assert_eq!(parse_duration("5m"), Some(Duration::from_secs(300)));
assert_eq!(parse_duration("2h"), Some(Duration::from_secs(7200)));
assert_eq!(parse_duration("abc"), None);
assert_eq!(parse_duration("5x"), None);
assert_eq!(parse_duration(""), None);
}
#[test]
fn short_duration_writes_valid_jsonl() {
let dir = std::env::temp_dir().join(format!("ltop-watch-e2e-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let out = dir.join("w.jsonl");
let lines = execute(
WatchOpts {
interval: Duration::from_secs(1),
duration: Some(Duration::from_secs(2)),
out: Some(out.clone()),
stop: None,
proc: None,
}, true)
.unwrap();
assert!(lines >= 2, "2s@1s 至少 2 行,实测 {lines}");
let content = std::fs::read_to_string(&out).unwrap();
let mut rows = content.lines();
let header = rows.next().unwrap();
assert!(header.contains("\"watch_start\""), "首行是表头:{header}");
let last = content.lines().last().unwrap();
let v: serde_json::Value = serde_json::from_str(last).unwrap();
assert_eq!(v["schema"], 1, "末行是 schema v1 快照");
assert!(
v["meta"]["hostname"]
.as_str()
.is_some_and(|h| !h.is_empty()),
"meta.hostname 非空"
);
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn proc_focus_writes_schema_rows() {
let dir = std::env::temp_dir().join(format!("ltop-watch-focus-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let out = dir.join("w.jsonl");
let lines = execute(
WatchOpts {
interval: Duration::from_secs(1),
duration: Some(Duration::from_secs(2)),
out: Some(out.clone()),
stop: None,
proc: Some("zzz-no-such-proc".into()),
}, true)
.unwrap();
assert!(lines >= 2);
let content = std::fs::read_to_string(&out).unwrap();
for row in content.lines().skip(1) {
let v: serde_json::Value = serde_json::from_str(row).unwrap();
assert!(
v["procs"].as_array().unwrap().iter().all(|p| {
p["name"]
.as_str()
.unwrap()
.to_lowercase()
.contains("zzz-no-such-proc")
}),
"聚焦模式下不应有未匹配进程"
);
}
std::fs::remove_dir_all(&dir).unwrap();
}
}