use crate::cli::conn::{AddArgs, ConnCommand, TestArgs};
use crate::conn::options::ConnectionSettings;
use crate::conn::profile::{Profile, SecretRef, SecretVault};
use crate::conn::store::ProfileStore;
use crate::error::{Failure, Result};
use crate::output::Envelope;
use serde_json::{json, Value};
mod reach;
mod profiles;
mod secret;
use secret::read_secret_from_standard_input;
pub async fn execute(
command: &ConnCommand,
config: &crate::config::Config,
cli: &crate::cli::Cli,
store: &mut ProfileStore,
vault: &mut dyn SecretVault,
settings: &ConnectionSettings,
) -> Result<Envelope> {
let marked = crate::dispatch::context::stored_default(config)?;
let refuses_to_ask = crate::settings::no_input(&cli.globals);
let settings_file =
crate::config::paths::config_file(cli.globals.diagnostics.config_dir.as_deref())?;
let conditions = Conditions {
refuses_to_ask,
dry_run: cli.globals.safety.dry_run,
};
match command {
ConnCommand::Add(args) => add(
args,
cli.globals.destination.database.as_deref(),
store,
vault,
marked.as_deref(),
&settings_file,
conditions,
),
ConnCommand::List => Ok(list(store, marked.as_deref())),
ConnCommand::Show(args) => show(
named(args.name.as_deref(), "conn show producao")?,
store,
marked.as_deref(),
),
ConnCommand::Edit(args) => profiles::edit(
named(args.name.as_deref(), "conn edit producao --host db.local")?,
&args.fields,
cli.globals.destination.database.as_deref(),
store,
vault,
conditions,
),
ConnCommand::Remove(args) => profiles::remove(
named(args.name.as_deref(), "conn remove producao")?,
store,
vault,
marked.as_deref(),
&settings_file,
conditions.dry_run,
),
ConnCommand::Default(args) => profiles::set_default(
named(args.name.as_deref(), "conn default producao")?,
store,
&settings_file,
conditions.dry_run,
),
ConnCommand::Test(args) => {
let budget = crate::settings::connect_timeout(config, &cli.globals)?;
reach::test(args, store, settings, marked.as_deref(), budget).await
}
}
}
#[derive(Debug, Clone, Copy)]
struct Conditions {
refuses_to_ask: bool,
dry_run: bool,
}
fn named<'a>(given: Option<&'a str>, example: &str) -> Result<&'a str> {
given.ok_or_else(|| {
Failure::usage(
"profile.name_missing",
"this command needs the name of a profile to work on",
)
.with_hint(format!(
"as in `{example}`; `conn list` shows the stored names"
))
})
}
fn add(
args: &AddArgs,
database: Option<&str>,
store: &mut ProfileStore,
vault: &mut dyn SecretVault,
marked: Option<&str>,
settings_file: &std::path::Path,
conditions: Conditions,
) -> Result<Envelope> {
let Conditions {
refuses_to_ask,
dry_run,
} = conditions;
let name = named(args.name.as_deref(), "conn add producao --host db.local")?;
let reference = SecretRef::for_profile(name);
let profile = Profile {
host: args.host.clone(),
port: args.port,
socket: args.socket.clone(),
user: args.user.clone(),
database: database.map(str::to_owned),
pin_database: args.pin_database.unwrap_or(false),
auth_method: args.auth.clone(),
secret: args.password_stdin.then(|| reference.clone()),
client_cert: args.client_cert.clone(),
client_key: args.client_key.clone(),
ca: args.ca.clone(),
require_tls: args.require_tls,
session_setup: args.session_setup.clone(),
read_only: args.read_only_profile.unwrap_or(false),
..Profile::named(name)
};
profile.ensure_reachable()?;
profile.ensure_pin_names_a_database()?;
if args.password_stdin {
let secret = read_secret_from_standard_input(refuses_to_ask)?;
if !dry_run {
vault.store(&reference, &secret)?;
}
}
let shown = profile.redacted();
store.add(profile)?;
if !dry_run {
store.save()?;
}
let became_default = marked.is_none();
if became_default && !dry_run {
crate::config::store::store(settings_file, "conn.default", name)?;
}
Ok(Envelope::new(
"conn add",
json!({
"created": true,
"profile": shown,
"is_default": became_default,
"simulated": dry_run,
}),
))
}
fn list(store: &ProfileStore, marked: Option<&str>) -> Envelope {
let rows: Vec<Value> = store
.list()
.iter()
.map(|profile| {
let mut shown = profile.redacted();
shown["is_default"] = json!(marked == Some(profile.name.as_str()));
shown
})
.collect();
Envelope::new("conn list", json!({ "rows": rows, "default": marked }))
}
fn show(name: &str, store: &ProfileStore, marked: Option<&str>) -> Result<Envelope> {
let profile = store.get(name)?;
let mut shown = profile.redacted();
shown["is_default"] = json!(marked == Some(name));
Ok(Envelope::new("conn show", shown))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cli::conn::NameArgs;
use secrecy::SecretString;
use std::collections::HashMap;
#[derive(Default)]
pub(super) struct MemoryVault {
secrets: HashMap<String, String>,
}
impl SecretVault for MemoryVault {
fn store(&mut self, reference: &SecretRef, secret: &SecretString) -> Result<()> {
use secrecy::ExposeSecret;
self.secrets.insert(
reference.key().to_owned(),
secret.expose_secret().to_owned(),
);
Ok(())
}
fn load(&self, reference: &SecretRef) -> Result<Option<SecretString>> {
Ok(self
.secrets
.get(reference.key())
.map(|secret| SecretString::from(secret.clone())))
}
fn forget(&mut self, reference: &SecretRef) -> Result<()> {
self.secrets.remove(reference.key());
Ok(())
}
}
pub(super) fn store_in(directory: &std::path::Path) -> ProfileStore {
ProfileStore::empty_at(directory.join("profiles.toml"))
}
fn add_args(name: &str) -> AddArgs {
AddArgs {
name: Some(name.to_owned()),
host: Some("db.example".to_owned()),
port: None,
socket: None,
user: Some("reader".to_owned()),
password_stdin: false,
pin_database: None,
auth: None,
client_cert: None,
client_key: None,
ca: None,
require_tls: None,
session_setup: Vec::new(),
read_only_profile: None,
check: false,
}
}
pub(super) fn settings_file_in(directory: &std::path::Path) -> std::path::PathBuf {
crate::config::paths::config_file(Some(directory)).expect("a settings location")
}
fn marked_in(directory: &std::path::Path) -> Option<String> {
let config = crate::config::Config::load(Some(directory)).expect("the location loads");
crate::dispatch::context::stored_default(&config).expect("resolves")
}
#[test]
fn a_simulated_create_leaves_the_store_and_the_registry_alone() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let file = settings_file_in(directory.path());
let envelope = add(
&add_args("main"),
Some("sales"),
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: true,
},
)
.expect("the destination is admissible");
assert_eq!(envelope.data["simulated"], true);
assert_eq!(
envelope.data["profile"]["host"], "db.example",
"a simulation still describes what it would have written"
);
assert!(
!directory.path().join("profiles.toml").exists(),
"the simulation wrote the store it was only asked to describe"
);
assert_eq!(
marked_in(directory.path()),
None,
"the simulation marked a default that was never created"
);
}
#[test]
fn a_simulated_create_still_refuses_what_the_real_one_refuses() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let file = settings_file_in(directory.path());
let mut args = add_args("empty");
args.host = None;
add(
&args,
None,
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: true,
},
)
.expect_err("a destination with no server is refused either way");
}
#[test]
fn a_simulated_removal_keeps_what_it_was_asked_to_describe() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let file = settings_file_in(directory.path());
add(
&add_args("main"),
None,
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: false,
},
)
.expect("added");
let envelope = profiles::remove("main", &mut store, &mut vault, Some("main"), &file, true)
.expect("the destination exists");
assert_eq!(envelope.data["simulated"], true);
assert_eq!(envelope.data["name"], "main");
let on_disk = ProfileStore::open(directory.path()).expect("the store opens");
assert_eq!(
on_disk.list().len(),
1,
"the simulation removed the destination it was only asked to describe"
);
}
#[test]
fn adding_stores_the_destination_and_reveals_no_secret() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let file = settings_file_in(directory.path());
let envelope = add(
&add_args("main"),
Some("sales"),
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: false,
},
)
.expect("added");
assert_eq!(envelope.data["created"], true);
assert_eq!(envelope.data["profile"]["host"], "db.example");
assert_eq!(
envelope.data["profile"]["database"], "sales",
"the database named by the global reaches the stored destination"
);
assert!(envelope.data["profile"]["secret"].is_null());
assert_eq!(
marked_in(directory.path()).as_deref(),
Some("main"),
"the first destination is marked in the registry, not in the store"
);
}
#[test]
fn adding_a_destination_with_no_server_is_refused() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let mut args = add_args("empty");
args.host = None;
let file = settings_file_in(directory.path());
let failure = add(
&args,
None,
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: false,
},
)
.expect_err("must refuse");
assert_eq!(failure.code(), "profile.no_destination");
assert!(store.list().is_empty(), "nothing may be stored on refusal");
}
#[test]
fn the_list_uses_the_published_key_and_hides_secrets() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
vault
.store(
&SecretRef::for_profile("main"),
&SecretString::from("hunter2"),
)
.expect("stored");
store
.add(Profile {
host: Some("db.example".to_owned()),
secret: Some(SecretRef::for_profile("main")),
..Profile::named("main")
})
.expect("added");
let envelope = list(&store, Some("main"));
let rows = envelope.data["rows"].as_array().expect("rows array");
assert_eq!(rows.len(), 1);
assert_eq!(rows[0]["is_default"], true);
assert_eq!(rows[0]["secret"], "***");
let text = serde_json::to_string(&envelope).expect("serialises");
assert!(!text.contains("hunter2"), "a secret leaked: {text}");
}
#[test]
fn showing_an_unknown_destination_is_an_absence() {
let directory = tempfile::tempdir().expect("temporary directory");
let failure = show("ghost", &store_in(directory.path()), None).expect_err("must refuse");
assert_eq!(failure.category(), crate::error::Category::Absence);
assert!(failure.hint().is_some());
}
#[test]
fn every_command_answers_under_its_published_name() {
let directory = tempfile::tempdir().expect("temporary directory");
let mut store = store_in(directory.path());
let mut vault = MemoryVault::default();
let file = settings_file_in(directory.path());
add(
&add_args("main"),
Some("sales"),
&mut store,
&mut vault,
None,
&file,
Conditions {
refuses_to_ask: false,
dry_run: false,
},
)
.expect("added");
assert_eq!(list(&store, Some("main")).command, "conn list");
assert_eq!(
show("main", &store, Some("main")).expect("shown").command,
"conn show"
);
assert_eq!(
profiles::set_default("main", &store, &file, false)
.expect("marked")
.command,
"conn default"
);
assert_eq!(
profiles::remove("main", &mut store, &mut vault, Some("main"), &file, false)
.expect("removed")
.command,
"conn remove"
);
assert_eq!(
ConnCommand::Test(TestArgs { name: None }).published_name(),
"conn test"
);
assert_eq!(
ConnCommand::Show(NameArgs {
name: Some("main".to_owned())
})
.published_name(),
"conn show"
);
}
}