pitchfork-cli 2.13.0

Daemons with DX
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use crate::Result;
use crate::boot_manager::BootManager;
use clap::Parser;

#[derive(Debug, Parser)]
#[clap(
    about = "Enable or disable boot start",
    long_about = "\
Enable or disable boot start

Manages whether pitchfork supervisor starts automatically when the system
boots. Uses platform-specific mechanisms (launchd on macOS, systemd on Linux).

When run as root (or via sudo), registers a system-level entry that starts
pitchfork for all users:
  macOS: /Library/LaunchDaemons/pitchfork.plist
  Linux: /etc/systemd/system/pitchfork.service

When run as a normal user, registers a user-level entry:
  macOS: ~/Library/LaunchAgents/pitchfork.plist
  Linux: ~/.config/systemd/user/pitchfork.service

To run the supervisor as root but keep state files and IPC sockets in a
specific user's home directory, set `settings.supervisor.user` in the global
pitchfork configuration (~/.config/pitchfork/config.toml or
/etc/pitchfork/config.toml).

Subcommands:
  enable    Register pitchfork to start on boot
  disable   Remove pitchfork from boot startup
  status    Check if boot start is currently enabled

Examples:
  pitchfork boot enable           Start pitchfork on system boot (user-level)
  sudo pitchfork boot enable      Start pitchfork on system boot (system-level)
  pitchfork boot disable          Don't start pitchfork on boot
  pitchfork boot status           Check boot start status"
)]
pub struct Boot {
    #[clap(subcommand)]
    command: BootCommands,
}

#[derive(Debug, clap::Subcommand)]
enum BootCommands {
    /// Enable boot start for pitchfork supervisor
    #[clap(long_about = "\
Enable boot start for pitchfork supervisor

Registers pitchfork to start automatically when the system boots.

When run as root (or via sudo): creates a system-level entry
  macOS: /Library/LaunchDaemons/pitchfork.plist
  Linux: /etc/systemd/system/pitchfork.service

When run as a normal user: creates a user-level entry
  macOS: ~/Library/LaunchAgents/pitchfork.plist
  Linux: ~/.config/systemd/user/pitchfork.service

If you want the supervisor to run as root but keep state files and IPC sockets
under a specific user's home directory, configure `settings.supervisor.user`
in your pitchfork configuration.")]
    Enable(BootEnable),
    /// Disable boot start for pitchfork supervisor
    #[clap(long_about = "\
Disable boot start for pitchfork supervisor

Removes the boot start registration. Pitchfork will no longer start
automatically on system boot.")]
    Disable(BootDisable),
    /// Check boot start status
    #[clap(long_about = "\
Check boot start status

Reports whether pitchfork is configured to start on system boot.")]
    Status(BootStatus),
}

#[derive(Debug, Parser)]
pub struct BootEnable {}

#[derive(Debug, Parser)]
pub struct BootDisable {}

#[derive(Debug, Parser)]
pub struct BootStatus {}

impl Boot {
    pub async fn run(&self) -> Result<()> {
        match &self.command {
            BootCommands::Enable(cmd) => cmd.run().await,
            BootCommands::Disable(cmd) => cmd.run().await,
            BootCommands::Status(cmd) => cmd.run().await,
        }
    }
}

impl BootEnable {
    async fn run(&self) -> Result<()> {
        let boot_manager = BootManager::new()?;

        if boot_manager.is_current_level_enabled()? {
            // Even if already enabled, clean up any leftover legacy entry
            // from a partial migration on a previous attempt.
            #[cfg(target_os = "macos")]
            boot_manager.cleanup_legacy(false)?;
            println!("Boot start is already enabled");
            return Ok(());
        }

        // enable() will error if the other privilege level is already registered.
        boot_manager.enable()?;
        info!("✓ Boot start enabled");

        Ok(())
    }
}

impl BootDisable {
    async fn run(&self) -> Result<()> {
        let boot_manager = BootManager::new()?;

        if !boot_manager.is_enabled()? {
            warn!("Boot start is already disabled");
            return Ok(());
        }

        boot_manager.disable()?;

        // disable() skips entries the caller lacks privileges to remove;
        // verify the result so we never report a false success.
        if boot_manager.is_enabled()? {
            miette::bail!(
                "boot start could not be fully disabled; \
                a system-level entry may require elevated privileges to remove"
            );
        }

        info!("✓ Boot start disabled");
        Ok(())
    }
}

impl BootStatus {
    async fn run(&self) -> Result<()> {
        let boot_manager = BootManager::new()?;
        let current_enabled = boot_manager.is_current_level_enabled()?;
        let other_enabled = boot_manager.is_other_level_enabled()?;

        match (current_enabled, other_enabled) {
            (true, true) => warn!(
                "Boot start is enabled at both user and system level; \
                run `pitchfork boot disable` (with appropriate privileges) to remove the unwanted entry"
            ),
            (true, false) => info!("Boot start is enabled"),
            (false, true) => warn!(
                "Boot start is registered at the other privilege level only; \
                run `pitchfork boot disable` (with appropriate privileges) to clean it up"
            ),
            (false, false) if boot_manager.is_enabled()? => info!("Boot start is enabled"),
            (false, false) => info!("Boot start is disabled"),
        }

        Ok(())
    }
}