#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TargetClass {
Host,
Service,
Repo,
Container,
Unknown,
}
impl TargetClass {
pub fn as_str(self) -> &'static str {
match self {
TargetClass::Host => "host",
TargetClass::Service => "service",
TargetClass::Repo => "repo",
TargetClass::Container => "container",
TargetClass::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Action {
pub verb: Option<String>,
pub target: Option<String>,
pub target_class: TargetClass,
}
impl Action {
pub fn unknown() -> Self {
Action {
verb: None,
target: None,
target_class: TargetClass::Unknown,
}
}
fn new(verb: &str, target: &str, class: TargetClass) -> Self {
Action {
verb: Some(verb.to_string()),
target: Some(target.to_string()),
target_class: class,
}
}
pub fn is_known(&self) -> bool {
self.target_class != TargetClass::Unknown
}
}
fn words(cmd: &str) -> Vec<&str> {
cmd.split_whitespace()
.map(|w| w.trim_matches(|c| c == '"' || c == '\''))
.filter(|w| !w.is_empty())
.collect()
}
fn is_compound(cmd: &str) -> bool {
cmd.contains('|')
|| cmd.contains(';')
|| cmd.contains("&&")
|| cmd.contains("||")
|| cmd.contains('`')
|| cmd.contains("$(")
|| cmd.contains('>')
|| cmd.contains('<')
}
fn host_operand(word: &str) -> Option<&str> {
if word.starts_with('-') {
return None;
}
let host_side = word.split(':').next()?;
if host_side.is_empty() || host_side.contains('/') {
return None;
}
let host = host_side.rsplit('@').next()?;
if host.is_empty() {
return None;
}
if host_side.contains('@') || host.contains('.') {
Some(host)
} else {
None
}
}
pub fn resolve(cmd: &str) -> Action {
let cmd = cmd.trim();
if cmd.is_empty() || is_compound(cmd) {
return Action::unknown();
}
let w = words(cmd);
let Some(argv0) = w.first() else {
return Action::unknown();
};
let prog = argv0.rsplit('/').next().unwrap_or(argv0);
match prog {
"ssh" | "scp" => {
w.iter()
.skip(1)
.find_map(|x| host_operand(x))
.map_or_else(Action::unknown, |h| Action::new(prog, h, TargetClass::Host))
}
"ansible" | "ansible-playbook" => {
let mut it = w.iter().skip(1);
while let Some(x) = it.next() {
if *x == "-l" || *x == "--limit" {
if let Some(v) = it.next() {
return Action::new(prog, v.trim_matches(','), TargetClass::Host);
}
return Action::unknown();
}
if let Some(v) = x.strip_prefix("--limit=") {
return Action::new(prog, v.trim_matches(','), TargetClass::Host);
}
}
Action::unknown()
}
"systemctl" => {
let verbs = [
"start", "stop", "restart", "reload", "enable", "disable", "mask", "unmask",
"kill", "status",
];
let mut rest = w.iter().skip(1).filter(|x| !x.starts_with('-'));
let Some(verb) = rest.next() else {
return Action::unknown();
};
if !verbs.contains(verb) {
return Action::unknown();
}
rest.next().map_or_else(Action::unknown, |unit| {
Action::new(
verb,
unit.trim_end_matches(".service"),
TargetClass::Service,
)
})
}
"git" => {
let sub = w.get(1).copied().unwrap_or("");
if !matches!(sub, "clone" | "push" | "pull" | "fetch") {
return Action::unknown();
}
w.iter()
.skip(2)
.find(|x| !x.starts_with('-'))
.and_then(|u| repo_name(u))
.map_or_else(Action::unknown, |r| Action::new(sub, &r, TargetClass::Repo))
}
"pct" | "docker" | "podman" => {
let verbs = [
"start", "stop", "restart", "exec", "destroy", "rm", "kill", "reboot",
];
let mut rest = w.iter().skip(1).filter(|x| !x.starts_with('-'));
let Some(verb) = rest.next() else {
return Action::unknown();
};
if !verbs.contains(verb) {
return Action::unknown();
}
rest.next().map_or_else(Action::unknown, |id| {
Action::new(verb, id, TargetClass::Container)
})
}
_ => Action::unknown(),
}
}
fn repo_name(url: &str) -> Option<String> {
let s = url.trim_end_matches('/').trim_end_matches(".git");
let last = s.rsplit(['/', ':']).next()?;
if last.is_empty() || last.contains(' ') {
return None;
}
Some(last.to_string())
}
#[cfg(test)]
#[allow(non_snake_case)]
mod tests {
use super::*;
fn r(cmd: &str) -> Action {
resolve(cmd)
}
#[test]
fn ssh_and_scp_resolve_a_host() {
assert_eq!(
r("ssh root@kota.lan"),
Action::new("ssh", "kota.lan", TargetClass::Host)
);
assert_eq!(
r("ssh -o BatchMode=yes braino@automation.lan"),
Action::new("ssh", "automation.lan", TargetClass::Host)
);
assert_eq!(
r("scp ./binary root@kota.lan:/opt/x"),
Action::new("scp", "kota.lan", TargetClass::Host)
);
}
#[test]
fn ansible_resolves_only_an_EXPLICIT_limit() {
assert_eq!(
r("ansible-playbook -i inventory.ini site.yml --limit kota.lan"),
Action::new("ansible-playbook", "kota.lan", TargetClass::Host)
);
assert_eq!(
r("ansible all -i inventory.ini -l kota.lan -m ping"),
Action::new("ansible", "kota.lan", TargetClass::Host)
);
assert!(!r("ansible quipu_servers -m ping").is_known());
}
#[test]
fn systemctl_resolves_a_service_and_strips_the_suffix() {
assert_eq!(
r("systemctl restart quipu"),
Action::new("restart", "quipu", TargetClass::Service)
);
assert_eq!(
r("systemctl stop rsyslog.service"),
Action::new("stop", "rsyslog", TargetClass::Service)
);
assert!(!r("systemctl frobnicate quipu").is_known());
assert!(!r("systemctl").is_known());
}
#[test]
fn git_resolves_only_forms_that_NAME_a_remote() {
assert_eq!(
r("git clone https://github.com/scbrown/bobbin.git"),
Action::new("clone", "bobbin", TargetClass::Repo)
);
assert_eq!(
r("git push git@github.com:scbrown/shantytown.git main"),
Action::new("push", "shantytown", TargetClass::Repo)
);
assert!(!r("git commit -m x").is_known());
}
#[test]
fn containers_resolve_by_known_verb_plus_id() {
assert_eq!(
r("pct restart 236"),
Action::new("restart", "236", TargetClass::Container)
);
assert_eq!(
r("docker stop bobbin"),
Action::new("stop", "bobbin", TargetClass::Container)
);
assert!(!r("docker ps").is_known());
}
#[test]
fn a_COMPOUND_line_abstains_because_it_is_not_one_action() {
for cmd in [
"ssh root@kota.lan | tee log",
"systemctl stop rsyslog && journalctl --vacuum-size=200M",
"echo $(ssh root@kota.lan hostname)",
"ssh root@kota.lan > out.txt",
] {
assert!(!r(cmd).is_known(), "resolved a compound line: {cmd}");
}
}
#[test]
fn everything_unrecognised_abstains_rather_than_guessing() {
for cmd in [
"",
" ",
"make deploy",
"./scripts/deploy-cutover.sh /tmp/bobbin",
"curl -s http://quipu.svc/query",
"rm -rf /var/log/journal",
] {
let a = r(cmd);
assert!(!a.is_known(), "guessed a target for: {cmd}");
assert_eq!(a.target_class, TargetClass::Unknown);
assert!(a.target.is_none() && a.verb.is_none());
}
}
#[test]
fn unknown_serialises_as_a_word_not_an_empty_string() {
assert_eq!(TargetClass::Unknown.as_str(), "unknown");
assert!(!Action::unknown().is_known());
}
#[test]
fn replaying_the_0jv06_deploy_shapes_names_the_target_host() {
let deploy_shapes = [
"ansible-playbook -i inventory.ini site.yml --tags quipu --limit kota.lan",
"scp target/release/quipu-server root@kota.lan:/opt/quipu/quipu-server",
"ssh root@kota.lan systemctl restart quipu",
];
for cmd in deploy_shapes {
let a = resolve(cmd);
assert!(a.is_known(), "deploy-shaped action did not resolve: {cmd}");
assert_eq!(
a.target.as_deref(),
Some("kota.lan"),
"wrong target for: {cmd}"
);
assert_eq!(a.target_class, TargetClass::Host);
}
}
}