ryra 0.9.6

A tool to test and deploy self-hosted services on a Linux server using rootless Podman and systemd. Built-in VM testing gives AI agents fast feedback loops for building infrastructure and deploying apps.
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

use anyhow::{Result, bail};
use ryra_core::Lifecycle;

use super::apply;

/// `ryra start` / `ryra stop`. Drives one service (and its sidecars) or,
/// with `--all`, every installed service through a start/stop transition.
///
/// `service` and `all` are mutually exclusive and exactly one is required
/// — clap enforces this at the arg layer, so reaching here with neither is
/// a defensive `bail!`.
pub async fn run(service: Option<&str>, all: bool, action: Lifecycle, dry_run: bool) -> Result<()> {
    let targets: Vec<String> = if all {
        let installed = ryra_core::list_installed()?;
        if installed.is_empty() {
            println!("No services installed.");
            return Ok(());
        }
        installed.into_iter().map(|s| s.name).collect()
    } else {
        match service {
            Some(s) => vec![s.to_string()],
            None => bail!("specify a service name or --all"),
        }
    };

    // Build the full step list up front so an unknown service name (e.g. a
    // typo, or `--all` racing a concurrent remove) fails before we start
    // toggling anything.
    let mut steps = Vec::new();
    for name in &targets {
        steps.extend(ryra_core::ops::plan_lifecycle(
            &ryra_core::ops::LifecycleRequest {
                service: name.to_string(),
                action,
            },
        )?);
    }

    if dry_run {
        super::print_dry_run(&steps);
        return Ok(());
    }

    let verb = match action {
        Lifecycle::Start => "Starting",
        Lifecycle::Stop => "Stopping",
    };
    println!("{verb} {}...", targets.join(", "));
    apply::execute_all(&steps).await?;
    Ok(())
}