systemg 0.61.2

An agent-friendly general process composer.
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

//! Typed diagnostics for `logs` mode-resolution failures — the checks that used
//! to be bare `eprintln!` + `exit(2)`.

use crate::diag::{Diagnostic, SgCode};

/// Builds the SG0204 diagnostic for mutually-exclusive `logs` mode flags.
pub fn conflicting_modes(modes: &[&str]) -> Diagnostic {
    Diagnostic::error(
        SgCode::ConflictingSelectors,
        format!("{} cannot be combined", modes.join(" and ")),
    )
    .note("each selects a different logs mode; pick one")
    .help_docs()
}

/// Builds the SG0204 diagnostic for `--follow` combined with a non-show mode.
pub fn follow_with_mode(mode: &str) -> Diagnostic {
    Diagnostic::error(
        SgCode::ConflictingSelectors,
        format!("--follow cannot be combined with {mode}"),
    )
    .note("--follow streams live logs; it only applies to the default show mode")
    .help_docs()
}

/// Builds the SG0017 diagnostic for `--prune` with no size or age bound.
pub fn prune_bound_missing() -> Diagnostic {
    Diagnostic::error(
        SgCode::PruneBoundMissing,
        "nothing to prune against: no --max-size or --max-age bound",
    )
    .note("prune trims rotated backups down to a bound; give it at least one")
    .help_cmd("cap total size", "sysg logs --prune --max-size 500MB")
    .help_cmd("drop old backups", "sysg logs --prune --max-age 7d")
    .help_docs()
}

/// Builds the SG0019 diagnostic for a bare `logs` with no target selector.
pub fn target_required() -> Diagnostic {
    Diagnostic::error(
        SgCode::LogsTargetRequired,
        "`sysg logs` needs a target: a service, a project, or --supervisor",
    )
    .note("bare `logs` is refused so it never dumps every project's output at once")
    .help_cmd("one service", "sysg logs -s <service>")
    .help_cmd("a whole project", "sysg logs -p <project>")
    .help_cmd("the supervisor log", "sysg logs --supervisor")
    .help_docs()
}

/// Builds the SG0020 diagnostic for `--supervisor` combined with a selector.
pub fn supervisor_with_selector() -> Diagnostic {
    Diagnostic::error(
        SgCode::LogsSupervisorConflict,
        "--supervisor cannot be combined with a service or project selector",
    )
    .note("the supervisor log is a single stream; it has no -s/-p scope")
    .help_cmd("supervisor log", "sysg logs --supervisor")
    .help_docs()
}

/// Builds the SG0021 diagnostic for `logs -s <service>` (no -p) where the
/// service is not in the loose bundle.
pub fn loose_service_not_found(service: &str) -> Diagnostic {
    Diagnostic::error(
        SgCode::LooseServiceNotFound,
        format!("no loose service named `{service}`"),
    )
    .note(
        "a bare `-s` reads only project-less (loose) services; a service inside a \
         project needs its project named",
    )
    .help_cmd(
        "target its project",
        format!("sysg logs -s {service} -p <project>"),
    )
    .help_docs()
}

/// Builds the SG0006 diagnostic for a service name several projects declare.
///
/// Only raised where acting on the wrong guess would be destructive — a purge
/// cannot be undone, so an ambiguous target is refused rather than resolved by
/// picking whichever project was found first.
pub fn ambiguous_service(service: &str, projects: &[String]) -> Diagnostic {
    let mut diag = Diagnostic::error(
        SgCode::TargetScopeAmbiguous,
        format!("service `{service}` exists in {} projects", projects.len()),
    )
    .note(format!("declared by: {}", projects.join(", ")))
    .note("nothing was purged; name the project to choose one");
    if let Some(first) = projects.first() {
        diag = diag.help_cmd(
            "purge one project's copy",
            format!("sysg logs --purge -s {service} -p {first}"),
        );
    }
    diag.help_docs()
}

/// Builds the SG0204 diagnostic for an unsupported `--format` value.
pub fn unsupported_format(format: &str) -> Diagnostic {
    Diagnostic::error(
        SgCode::ConflictingSelectors,
        format!("`sysg logs` does not support --format {format}"),
    )
    .note("logs are line-oriented; use --format json for machine output")
    .help_docs()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn conflicting_modes_is_sg0204_and_names_them() {
        let diag = conflicting_modes(&["--path", "--purge"]);
        assert_eq!(diag.code, SgCode::ConflictingSelectors);
        assert!(diag.render(false).contains("--path and --purge"));
    }

    #[test]
    fn prune_bound_missing_is_sg0017() {
        let diag = prune_bound_missing();
        assert_eq!(diag.code, SgCode::PruneBoundMissing);
        assert!(diag.render(false).contains("SG0017"));
    }

    #[test]
    fn follow_with_mode_is_sg0204() {
        let diag = follow_with_mode("--path");
        assert_eq!(diag.code, SgCode::ConflictingSelectors);
    }
}