use super::text::join;
use super::{Compact, Family, Plan, Run};
const VALUE_OPTIONS: &[&str] = &[
"--config",
"-c",
"--context",
"-H",
"--host",
"-l",
"--log-level",
"--tlscacert",
"--tlscert",
"--tlskey",
];
pub(super) fn plan(rest: &[String]) -> Plan {
let words: Vec<&str> = super::skip_options(rest, VALUE_OPTIONS)
.iter()
.map(String::as_str)
.filter(|a| !a.starts_with('-'))
.collect();
let lists = matches!(
words.as_slice(),
["ps", ..] | ["container", "ls" | "ps" | "list", ..]
);
let ids_only = super::has_flag(rest, &["--quiet"]) || super::has_short(rest, "q");
if lists && !ids_only {
Plan::Filter(Family::DockerPs)
} else {
Plan::Passthrough
}
}
fn column_starts(header: &[char]) -> Vec<usize> {
let mut starts = Vec::new();
for (i, &c) in header.iter().enumerate() {
let gap = i == 0 || (header[i - 1] == ' ' && i >= 2 && header[i - 2] == ' ');
if c != ' ' && gap {
starts.push(i);
}
}
starts
}
fn ports(cell: &str) -> String {
let entries: Vec<&str> = cell.split(", ").collect();
let kept: Vec<&str> = entries
.iter()
.copied()
.filter(|p| {
let v6 = p.strip_prefix(":::").or_else(|| p.strip_prefix("[::]:"));
v6.is_none_or(|rest| !entries.contains(&format!("0.0.0.0:{rest}").as_str()))
})
.collect();
kept.join(", ")
}
pub(super) fn ps(run: &Run<'_>) -> Option<Compact> {
let mut lines = run.stdout.lines();
let header: Vec<char> = lines.next()?.chars().collect();
let head: String = header.iter().collect();
if run.code != 0 || !head.starts_with("CONTAINER ID") {
return None;
}
let starts = column_starts(&header);
let name = |k: usize| -> String {
let end = starts.get(k + 1).copied().unwrap_or(header.len());
header[starts[k]..end]
.iter()
.collect::<String>()
.trim()
.to_string()
};
let names: Vec<String> = (0..starts.len()).map(name).collect();
let keep: Vec<usize> = (0..starts.len())
.filter(|&k| names[k] != "COMMAND" && names[k] != "CREATED")
.collect();
if keep.len() == starts.len() || !names.iter().any(|n| n == "IMAGE") {
return None;
}
let row = |cells: Vec<String>| -> String {
cells
.iter()
.map(|c| c.trim())
.filter(|c| !c.is_empty())
.collect::<Vec<_>>()
.join(" ")
};
let mut out = vec![row(keep.iter().map(|&k| names[k].clone()).collect())];
for line in lines {
let chars: Vec<char> = line.chars().collect();
let cells = keep
.iter()
.map(|&k| {
let from = starts[k].min(chars.len());
let to = starts
.get(k + 1)
.copied()
.unwrap_or(chars.len())
.min(chars.len());
let cell: String = chars[from..to].iter().collect();
if names[k] == "PORTS" {
ports(cell.trim())
} else {
cell
}
})
.collect();
out.push(row(cells));
}
Some(Compact {
stdout: join(&out),
stderr: run.stderr.to_string(),
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tk::tests::{run, words as args};
fn table(rows: &[[&str; 7]]) -> String {
let widths: Vec<usize> = (0..7)
.map(|c| rows.iter().map(|r| r[c].chars().count()).max().unwrap() + 3)
.collect();
let mut out = String::new();
for row in rows {
let mut line = String::new();
for (c, cell) in row.iter().enumerate() {
if c == 6 {
line.push_str(cell);
} else {
line.push_str(&format!("{cell:<width$}", width = widths[c]));
}
}
out.push_str(line.trim_end());
out.push('\n');
}
out
}
fn ps_fixture() -> String {
table(&[
[
"CONTAINER ID",
"IMAGE",
"COMMAND",
"CREATED",
"STATUS",
"PORTS",
"NAMES",
],
[
"3f2a1b9c8d7e",
"nginx:latest",
"\"/docker-entrypoint.…\"",
"2 hours ago",
"Up 2 hours",
"0.0.0.0:8080->80/tcp, :::8080->80/tcp",
"web",
],
[
"a1b2c3d4e5f6",
"postgres:16",
"\"docker-entrypoint.s…\"",
"3 days ago",
"Up 3 days",
"5432/tcp",
"db",
],
[
"0a9b8c7d6e5f",
"redis:7",
"\"redis-server\"",
"10 minutes ago",
"Exited (0) 1 minute ago",
"",
"cache",
],
])
}
#[test]
fn ps_keeps_id_image_status_ports_and_names() {
let fixture = ps_fixture();
let r = run(0, &fixture, "");
let out = ps(&r).unwrap().stdout;
assert_eq!(
out,
"CONTAINER ID IMAGE STATUS PORTS NAMES
3f2a1b9c8d7e nginx:latest Up 2 hours 0.0.0.0:8080->80/tcp web
a1b2c3d4e5f6 postgres:16 Up 3 days 5432/tcp db
0a9b8c7d6e5f redis:7 Exited (0) 1 minute ago cache
"
);
assert!(out.len() < fixture.len());
}
#[test]
fn a_table_it_does_not_recognize_is_left_alone() {
for stdout in [
"NAME STATUS\nweb up\n",
"CONTAINER ID IMAGE STATUS NAMES\nabc x Up web\n",
"",
] {
let r = Run {
code: 0,
stdout,
stderr: "",
};
assert!(ps(&r).is_none(), "{stdout:?}");
}
let fixture = ps_fixture();
let failed = run(1, &fixture, "Cannot connect to the Docker daemon\n");
assert!(ps(&failed).is_none());
}
#[test]
fn an_ipv6_port_stays_unless_an_ipv4_one_repeats_it() {
assert_eq!(
ports("0.0.0.0:8080->80/tcp, :::8080->80/tcp"),
"0.0.0.0:8080->80/tcp"
);
assert_eq!(
ports("0.0.0.0:8080->80/tcp, [::]:8080->80/tcp, [::]:9090->90/tcp"),
"0.0.0.0:8080->80/tcp, [::]:9090->90/tcp"
);
assert_eq!(ports("[::]:8080->80/tcp"), "[::]:8080->80/tcp");
assert_eq!(ports(":::8080->80/tcp"), ":::8080->80/tcp");
assert_eq!(ports("5432/tcp"), "5432/tcp");
}
#[test]
fn plans() {
let p = |line: &str| crate::tk::plan(&args(line));
for line in [
"docker ps",
"docker ps -a",
"docker container ls",
"docker ps --filter status=exited",
"docker --context remote ps",
"docker -H tcp://h:2375 container ls",
"docker --context=remote ps -a",
] {
assert_eq!(p(line), Plan::Filter(Family::DockerPs), "{line}");
}
for line in [
"docker ps -q",
"docker ps -aq",
"docker ps --quiet",
"docker ps --format {{.Names}}",
"docker run -it ubuntu",
"docker logs -f web",
"docker exec web ls",
"docker images",
"docker",
] {
assert_eq!(p(line), Plan::Passthrough, "{line}");
}
}
}