args-cli 0.1.1

Command-line interface for args
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use anyhow::Context;

use super::{Service, ServiceManager};
use crate::{config::runner::SYSTEM_USER, util::run_command};

const SERVICE_NAME: &str = "args-runner";
const UNIT_PATH: &str = "/etc/systemd/system/args-runner.service";

impl Service for ServiceManager {
    fn install(&self) -> anyhow::Result<()> {
        let unit = format!(
            "[Unit]
Description=Args Runner
After=network.target

[Service]
ExecStart={binary} ci run
User={user}
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier={name}

[Install]
WantedBy=multi-user.target
",
            binary = self.binary_path,
            user = SYSTEM_USER,
            name = SERVICE_NAME,
        );

        std::fs::write(UNIT_PATH, unit).with_context(|| {
            format!(
                "Failed to write unit file to {} (try running with sudo)",
                UNIT_PATH
            )
        })?;

        run_command("sudo", &["systemctl", "daemon-reload"])
            .context("Failed to reload systemd daemon")?;

        run_command("sudo", &["systemctl", "enable", SERVICE_NAME])
            .context("Failed to enable systemd service")?;

        Ok(())
    }

    fn uninstall(&self) -> anyhow::Result<()> {
        // Best-effort: ignore errors and suppress output (service may not be installed yet)
        let silent = |args: &[&str]| {
            let _ = std::process::Command::new("sudo")
                .args(args)
                .stdout(std::process::Stdio::null())
                .stderr(std::process::Stdio::null())
                .status();
        };
        silent(&["systemctl", "stop", SERVICE_NAME]);
        silent(&["systemctl", "disable", SERVICE_NAME]);
        let _ = std::fs::remove_file(UNIT_PATH);
        silent(&["systemctl", "daemon-reload"]);
        Ok(())
    }

    fn start(&self) -> anyhow::Result<()> {
        run_command("sudo", &["systemctl", "start", SERVICE_NAME])
            .context("Failed to start systemd service")?;
        Ok(())
    }

    fn stop(&self) -> anyhow::Result<()> {
        run_command("sudo", &["systemctl", "stop", SERVICE_NAME])
            .context("Failed to stop systemd service")?;
        Ok(())
    }
}