313 lines
11 KiB
Rust
313 lines
11 KiB
Rust
mod extended;
|
|
use std::{
|
|
env, fs,
|
|
io::{self, Write},
|
|
path::{Path, PathBuf},
|
|
process::Command,
|
|
time::{SystemTime, UNIX_EPOCH},
|
|
};
|
|
const DATA: &str = "/mnt/intake-data";
|
|
fn prompt(q: &str) -> String {
|
|
print!("{}", q);
|
|
let _ = io::stdout().flush();
|
|
let mut s = String::new();
|
|
let _ = io::stdin().read_line(&mut s);
|
|
s.trim().to_string()
|
|
}
|
|
fn run(program: &str, args: &[&str]) -> Result<(), String> {
|
|
let st = Command::new(program)
|
|
.args(args)
|
|
.status()
|
|
.map_err(|e| format!("{}: {}", program, e))?;
|
|
if st.success() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("{} exited with {}", program, st))
|
|
}
|
|
}
|
|
fn capture(program: &str, args: &[&str]) -> Result<String, String> {
|
|
let o = Command::new(program)
|
|
.args(args)
|
|
.output()
|
|
.map_err(|e| e.to_string())?;
|
|
if !o.status.success() {
|
|
return Err(String::from_utf8_lossy(&o.stderr).to_string());
|
|
}
|
|
Ok(String::from_utf8_lossy(&o.stdout).trim().to_string())
|
|
}
|
|
fn sqlquote(s: &str) -> String {
|
|
format!("'{}'", s.replace('\'', "''"))
|
|
}
|
|
fn db_path(data: &Path) -> PathBuf {
|
|
data.join("database/intake.sqlite3")
|
|
}
|
|
fn sql(data: &Path, statement: &str) -> Result<String, String> {
|
|
capture(
|
|
"sqlite3",
|
|
&[db_path(data).to_str().ok_or("Invalid DB path")?, statement],
|
|
)
|
|
}
|
|
fn init(data: &Path) -> Result<(), String> {
|
|
for part in ["database", "reports", "checklists", "config"] {
|
|
fs::create_dir_all(data.join(part)).map_err(|e| e.to_string())?;
|
|
}
|
|
let probe = data.join(".write-test");
|
|
fs::write(&probe, b"ok").map_err(|e| format!("Persistent partition not writable: {}", e))?;
|
|
let _ = fs::remove_file(probe);
|
|
sql(data,"PRAGMA journal_mode=DELETE; CREATE TABLE IF NOT EXISTS scans (id INTEGER PRIMARY KEY AUTOINCREMENT, asset_id TEXT NOT NULL, timestamp INTEGER NOT NULL, report_path TEXT NOT NULL UNIQUE, inspection_path TEXT, inspection_status TEXT NOT NULL DEFAULT 'NOT_TESTED', sync_status TEXT NOT NULL DEFAULT 'PENDING', synced_inventory_id TEXT);")?;
|
|
Ok(())
|
|
}
|
|
fn valid_id(s: &str) -> bool {
|
|
!s.is_empty()
|
|
&& s.len() <= 64
|
|
&& s.bytes()
|
|
.all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
|
|
}
|
|
fn latest(data: &Path, id: &str) -> Option<PathBuf> {
|
|
let root = data.join("reports").join(id);
|
|
let mut matches = Vec::new();
|
|
for d in fs::read_dir(root).ok()?.flatten() {
|
|
let p = d.path().join("report.json");
|
|
if p.is_file() {
|
|
let mt = p.metadata().ok()?.modified().ok()?;
|
|
matches.push((mt, p));
|
|
}
|
|
}
|
|
matches.sort_by_key(|(m, _)| *m);
|
|
matches.pop().map(|(_, p)| p)
|
|
}
|
|
fn get_time() -> u64 {
|
|
SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.as_secs()
|
|
}
|
|
fn scan(data: &Path, quick: bool) {
|
|
let id = prompt("Asset ID: ");
|
|
if !valid_id(&id) {
|
|
println!("Invalid ID (letters, digits, underscore and hyphen only)");
|
|
return;
|
|
}
|
|
let out = data.join("reports");
|
|
let outstr = out.to_string_lossy().to_string();
|
|
let mut cmd = Command::new("/usr/local/bin/pc-intake");
|
|
cmd.args(["--asset-id", &id, "--output", &outstr]);
|
|
if quick {
|
|
cmd.arg("--quick");
|
|
} else {
|
|
cmd.arg("--compile");
|
|
}
|
|
let checklist = data.join("checklists").join(format!("{}.txt", id));
|
|
if checklist.exists() {
|
|
cmd.args(["--checklist", &checklist.to_string_lossy()]);
|
|
}
|
|
println!("Running {} scan...", if quick { "quick" } else { "full" });
|
|
match cmd.status() {
|
|
Ok(status) if status.success() => {
|
|
if let Some(report) = latest(data, &id) {
|
|
let result=sql(data,&format!("INSERT OR IGNORE INTO scans(asset_id,timestamp,report_path) VALUES({},{},{});",sqlquote(&id),get_time(),sqlquote(&report.to_string_lossy())));
|
|
match result {
|
|
Ok(_) => {
|
|
println!("Saved: {}", report.display());
|
|
println!("Inventory sync: PENDING (not uploaded)");
|
|
}
|
|
Err(e) => println!("Database write failed: {}. JSON report remains saved.", e),
|
|
}
|
|
} else {
|
|
println!("Scanner exited successfully, but no report found");
|
|
}
|
|
}
|
|
Ok(status) => println!("Scanner failed: {}", status),
|
|
Err(e) => println!("Could not launch scanner: {}", e),
|
|
}
|
|
}
|
|
const CHECKS: &[(&str, &str)] = &[
|
|
(
|
|
"display",
|
|
"Show colors/brightness and inspect for dead pixels",
|
|
),
|
|
(
|
|
"keyboard",
|
|
"Check every key, including modifiers and function keys",
|
|
),
|
|
(
|
|
"touchpad",
|
|
"Verify movement, taps, buttons and scrolling; N/A for desktop",
|
|
),
|
|
(
|
|
"wifi",
|
|
"Connect to a network and open a local or remote test service",
|
|
),
|
|
("audio", "Play left/right sound and check for distortion"),
|
|
("microphone", "Record voice and play it back"),
|
|
(
|
|
"webcam",
|
|
"Preview image and verify focus and quality; N/A if absent",
|
|
),
|
|
(
|
|
"usb_ports",
|
|
"Insert a known-good test device in each physical port",
|
|
),
|
|
(
|
|
"charging",
|
|
"Verify AC adapter, charging status, battery runtime; N/A for desktop",
|
|
),
|
|
("thermals", "Verify fans, heat and sustained load"),
|
|
(
|
|
"stability",
|
|
"Check for crashes, unexpected resets or kernel errors",
|
|
),
|
|
];
|
|
fn technician(data: &Path) {
|
|
let id = prompt("Asset ID for inspection: ");
|
|
if !valid_id(&id) {
|
|
println!("Invalid ID");
|
|
return;
|
|
}
|
|
let mut rows = Vec::new();
|
|
for (key, desc) in CHECKS {
|
|
println!("\n{}: {}", key, desc);
|
|
if *key == "audio" {
|
|
println!("Optional speaker test (if installed): speaker-test -c 2 -t wav");
|
|
}
|
|
if *key == "webcam" {
|
|
println!(
|
|
"Optional camera detection: ls /dev/video*; preview requires graphical session"
|
|
);
|
|
}
|
|
loop {
|
|
let ans = prompt("[p]ass / [f]ail / [u]ntested / [n]ot applicable: ").to_lowercase();
|
|
if let Some(st) = match ans.as_str() {
|
|
"p" => Some("PASS"),
|
|
"f" => Some("FAIL"),
|
|
"u" | "" => Some("NOT_TESTED"),
|
|
"n" => Some("NOT_APPLICABLE"),
|
|
_ => None,
|
|
} {
|
|
rows.push((key.to_string(), st.to_string()));
|
|
break;
|
|
}
|
|
println!("Enter p, f, u or n");
|
|
}
|
|
}
|
|
let target = data.join("checklists").join(format!("{}.txt", id));
|
|
let mut raw = String::new();
|
|
for (k, v) in &rows {
|
|
raw.push_str(&format!("{}={}\n", k, v));
|
|
}
|
|
if let Err(e) = fs::write(&target, raw) {
|
|
println!("Could not save checklist: {}", e);
|
|
return;
|
|
}
|
|
let fail = rows.iter().any(|(_, s)| s == "FAIL");
|
|
let unknown = rows.iter().any(|(_, s)| s == "NOT_TESTED");
|
|
let verdict = if fail {
|
|
"FAIL"
|
|
} else if unknown {
|
|
"INCOMPLETE"
|
|
} else {
|
|
"COMPLETED"
|
|
};
|
|
let _=sql(data,&format!("UPDATE scans SET inspection_path={},inspection_status={} WHERE id=(SELECT MAX(id) FROM scans WHERE asset_id={});",sqlquote(&target.to_string_lossy()),sqlquote(verdict),sqlquote(&id)));
|
|
println!(
|
|
"Inspection {}. Saved {}; re-scan to embed checklist in hardware report.",
|
|
verdict,
|
|
target.display()
|
|
);
|
|
}
|
|
fn recent(data: &Path) {
|
|
let query = "SELECT id || ' | ' || asset_id || ' | ' || inspection_status || ' | ' || sync_status || ' | ' || report_path FROM scans ORDER BY id DESC LIMIT 20;";
|
|
match sql(data, query) {
|
|
Ok(rows) if rows.is_empty() => println!("No scans yet."),
|
|
Ok(rows) => println!("{}", rows),
|
|
Err(err) => println!("Database error: {}", err),
|
|
}
|
|
}
|
|
fn help() {
|
|
println!("PC Intake AIO v1.7.0 — offline-first technician controller");
|
|
println!("Usage: intake-controller [--data PATH] [--self-check]");
|
|
}
|
|
fn main() {
|
|
let args: Vec<String> = env::args().collect();
|
|
if args.iter().any(|x| x == "--help") {
|
|
help();
|
|
return;
|
|
}
|
|
if args.iter().any(|x| x == "--self-check") {
|
|
for tool in [
|
|
"sqlite3",
|
|
"smartctl",
|
|
"ffmpeg",
|
|
"mpv",
|
|
"glmark2",
|
|
"stress-ng",
|
|
"memtester",
|
|
"speaker-test",
|
|
] {
|
|
println!(
|
|
"{}: {}",
|
|
tool,
|
|
if Command::new("sh")
|
|
.args(["-c", &format!("command -v {} >/dev/null", tool)])
|
|
.status()
|
|
.map(|s| s.success())
|
|
.unwrap_or(false)
|
|
{
|
|
"FOUND"
|
|
} else {
|
|
"MISSING"
|
|
}
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
let data = if let Some(p) = args.iter().position(|x| x == "--data") {
|
|
PathBuf::from(args.get(p + 1).unwrap_or(&DATA.to_owned()))
|
|
} else {
|
|
PathBuf::from(DATA)
|
|
};
|
|
if let Err(e) = init(&data) {
|
|
eprintln!("FATAL: {} — refusing to scan without persistent storage", e);
|
|
std::process::exit(1)
|
|
}
|
|
loop {
|
|
println!("\n==== PC INTAKE AIO v1.7.0 ====\nStorage: {}\n1 Full scan and local queue\n2 Quick inventory\n3 Guided technician checklist\n4 Recent scans and sync states\n5 Check diagnostic tools\n6 Safely power off\n7 Hardware details (UUID / MAC / RAM slots / screen)\n8 Guided audio / webcam / Wi-Fi test\n9 Installed-system maintenance instructions\n10 CPU and RAM stress test (opt-in)\n",data.display());
|
|
match prompt("Select: ").as_str() {
|
|
"1" => scan(&data, false),
|
|
"2" => scan(&data, true),
|
|
"3" => technician(&data),
|
|
"4" => recent(&data),
|
|
"5" => {
|
|
let _ = Command::new(
|
|
env::current_exe().unwrap_or_else(|_| PathBuf::from("intake-controller")),
|
|
)
|
|
.arg("--self-check")
|
|
.status();
|
|
}
|
|
"6" => {
|
|
let _ = run("sync", &[]);
|
|
let _ = run("systemctl", &["poweroff"]);
|
|
break;
|
|
}
|
|
"7" => extended::device_details(&data),
|
|
"8" => extended::guided_tests(&data),
|
|
"9" => extended::maintenance_guidance(),
|
|
"10" => extended::stress_test(&data),
|
|
_ => println!("Unknown selection"),
|
|
}
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn id_validation() {
|
|
assert!(valid_id("PC-0123"));
|
|
assert!(!valid_id("../../evil"));
|
|
}
|
|
#[test]
|
|
fn sql_escape() {
|
|
assert_eq!(sqlquote("O'Reilly"), "'O''Reilly'");
|
|
}
|
|
}
|