use std::time::Duration;
use anyhow::{Context, Result, bail};
use serde::Deserialize;
use crate::api;
const USAGE: &str =
"usage: sb device list\n sb device remove <name> [--keep <name>]... [--yes]";
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum DeviceArgs {
List,
Remove {
device: String,
keep: Vec<String>,
yes: bool,
},
}
impl DeviceArgs {
pub(crate) fn parse(args: &[String]) -> Result<DeviceArgs> {
match args.first().map(String::as_str) {
Some("list") if args.len() == 1 => Ok(DeviceArgs::List),
Some("remove") => {
let mut device = None;
let mut keep = Vec::new();
let mut yes = false;
let mut words = args[1..].iter();
while let Some(word) = words.next() {
match word.as_str() {
"--keep" => keep.push(
words
.next()
.with_context(|| format!("--keep needs a device name\n{USAGE}"))?
.clone(),
),
"--yes" => yes = true,
flag if flag.starts_with("--") => {
bail!("unexpected argument {flag:?}\n{USAGE}")
}
name if device.is_none() => device = Some(name.to_string()),
extra => bail!("unexpected argument {extra:?}\n{USAGE}"),
}
}
let device =
device.with_context(|| format!("name the device to remove\n{USAGE}"))?;
Ok(DeviceArgs::Remove { device, keep, yes })
}
_ => bail!("{USAGE}"),
}
}
}
#[derive(Debug, Deserialize)]
struct DeviceView {
machine_id: String,
name: String,
#[serde(default)]
this_device: bool,
#[serde(default)]
revoked: bool,
}
impl DeviceView {
fn label(&self) -> String {
if self.name.is_empty() || self.name == self.machine_id {
self.machine_id.clone()
} else {
format!("{} ({})", self.name, self.machine_id)
}
}
}
#[derive(Deserialize)]
struct DeviceList {
identity: Option<String>,
devices: Vec<DeviceView>,
}
#[derive(Debug, Deserialize)]
struct RemoveResponse {
target: DeviceView,
revoked: Vec<DeviceView>,
epoch: Option<u32>,
#[serde(default)]
access_error: Option<String>,
}
fn unconfirmed(preview: &RemoveResponse, yes: bool) -> Option<String> {
let extra: Vec<&DeviceView> = preview
.revoked
.iter()
.filter(|d| d.machine_id != preview.target.machine_id)
.collect();
if extra.is_empty() || yes {
return None;
}
let mut message = format!(
"removing {} also removes the devices it added, directly or through others:\n",
preview.target.label()
);
for device in &extra {
message.push_str(&format!(" {}\n", device.label()));
}
message.push_str(
"keep the ones you still hold with --keep <name>, or pass --yes to remove them all",
);
Some(message)
}
pub(crate) fn cmd_device(args: &[String]) -> Result<()> {
let client = api::client(Duration::from_secs(60))?;
let base = api::base_url();
match DeviceArgs::parse(args)? {
DeviceArgs::List => {
let list: DeviceList = api::daemon_ok(
client
.get(format!("{base}/v1/devices"))
.send()
.context("listing devices on the daemon")?,
)?
.json()?;
let Some(identity) = list.identity else {
println!("this device holds no sync identity; pair it with `sb pair`");
return Ok(());
};
println!("sync identity {identity}");
for device in &list.devices {
let state = match (device.this_device, device.revoked) {
(true, true) => "this device, removed",
(true, false) => "this device",
(false, true) => "removed",
(false, false) => "active",
};
println!(" {:<40} {state}", device.label());
}
Ok(())
}
DeviceArgs::Remove { device, keep, yes } => {
let remove = |dry_run: bool, expected: Option<Vec<&str>>| -> Result<RemoveResponse> {
Ok(api::daemon_ok(
client
.post(format!("{base}/v1/devices/remove"))
.json(&serde_json::json!({
"device": device,
"keep": keep,
"dry_run": dry_run,
"expected": expected,
}))
.send()
.context("calling device removal on the daemon")?,
)?
.json()?)
};
let preview = remove(true, None)?;
if let Some(refusal) = unconfirmed(&preview, yes) {
bail!("{refusal}");
}
let shown = preview
.revoked
.iter()
.map(|d| d.machine_id.as_str())
.collect();
let done = remove(false, Some(shown))?;
let names: Vec<String> = done.revoked.iter().map(DeviceView::label).collect();
println!("removed {}", names.join(", "));
if let Some(epoch) = done.epoch {
println!(
"minted key epoch {epoch}; the remaining devices receive it at their next sync"
);
}
if let Some(error) = &done.access_error {
eprintln!(
"warning: the daemon could not finish cutting the removed devices' ssh \
access, and retries after every sync: {error}"
);
}
Ok(())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn words(line: &str) -> Vec<String> {
line.split_whitespace().map(str::to_string).collect()
}
#[test]
fn arguments_parse_into_a_command_or_the_usage() {
assert_eq!(DeviceArgs::parse(&words("list")).unwrap(), DeviceArgs::List);
assert_eq!(
DeviceArgs::parse(&words("remove laptop --keep pi --keep mac --yes")).unwrap(),
DeviceArgs::Remove {
device: "laptop".into(),
keep: vec!["pi".into(), "mac".into()],
yes: true,
}
);
assert_eq!(
DeviceArgs::parse(&words("remove --keep pi laptop")).unwrap(),
DeviceArgs::Remove {
device: "laptop".into(),
keep: vec!["pi".into()],
yes: false,
}
);
for bad in [
"",
"list extra",
"remove",
"remove a b",
"remove a --keep",
"remove a --lost",
"add a",
] {
let err = format!("{:#}", DeviceArgs::parse(&words(bad)).unwrap_err());
assert!(err.contains("usage: sb device"), "{bad:?}: {err}");
}
}
fn view(id: &str, name: &str) -> DeviceView {
DeviceView {
machine_id: id.into(),
name: name.into(),
this_device: false,
revoked: false,
}
}
#[test]
fn devices_beyond_the_target_need_keep_or_yes() {
let alone = RemoveResponse {
target: view("m1", "laptop"),
revoked: vec![view("m1", "laptop")],
epoch: None,
access_error: None,
};
assert_eq!(unconfirmed(&alone, false), None);
let more = RemoveResponse {
target: view("m1", "laptop"),
revoked: vec![view("m1", "laptop"), view("m2", "pi")],
epoch: None,
access_error: None,
};
assert_eq!(unconfirmed(&more, true), None);
let refusal = unconfirmed(&more, false).unwrap();
assert!(refusal.contains("pi (m2)"), "{refusal}");
assert!(!refusal.contains(" laptop"), "{refusal}");
assert!(refusal.contains("--keep"), "{refusal}");
}
}