use std::io::Write as _;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use clap::ArgAction;
use cpa_core::config::Config;
use cpa_plugin::Host;
use cpa_plugin::cli::{CliFlag, Output};
pub trait PluginFlags {
fn lookup(&self, name: &str) -> Option<bool>;
fn set(&self, name: &str, value: &str) -> Result<(), String>;
}
impl PluginFlags for () {
fn lookup(&self, _: &str) -> Option<bool> {
None
}
fn set(&self, _: &str, _: &str) -> Result<(), String> {
Ok(())
}
}
impl PluginFlags for Host {
fn lookup(&self, name: &str) -> Option<bool> {
self.command_line_flag(name).map(|f| f.kind == "bool")
}
fn set(&self, name: &str, value: &str) -> Result<(), String> {
self.set_command_line_flag(name, value)
}
}
pub fn bootstrap_config_path(args: &[String], default: &str) -> PathBuf {
let mut i = 0;
while i < args.len() {
let arg = args[i].as_str();
match arg {
"--" => break,
"-config" | "--config" => {
return match args.get(i + 1) {
Some(path) => PathBuf::from(path),
None => default_config_path(default),
};
}
_ => {
if let Some(path) = arg.strip_prefix("-config=").or_else(|| arg.strip_prefix("--config=")) {
return PathBuf::from(path);
}
}
}
i += 1;
}
default_config_path(default)
}
fn default_config_path(default: &str) -> PathBuf {
if !default.trim().is_empty() {
return PathBuf::from(default);
}
match std::env::current_dir() {
Ok(wd) => wd.join("config.yaml"),
Err(_) => PathBuf::from("config.yaml"),
}
}
pub fn load_bootstrap_config(path: &Path) -> Config {
let empty = || Config::parse("").expect("an empty config parses");
let raw = match std::fs::read(path) {
Ok(raw) => raw,
Err(e) => {
if e.kind() != std::io::ErrorKind::NotFound {
tracing::warn!("failed to read plugin bootstrap config: {e}");
}
return empty();
}
};
let text = String::from_utf8_lossy(&raw);
if text.trim().is_empty() {
return empty();
}
Config::parse(&text).unwrap_or_else(|e| {
tracing::warn!("failed to parse plugin bootstrap config: {e:#}");
empty()
})
}
pub async fn bootstrap(args: &[String], builtin: &dyn Fn(&str) -> bool) -> (Host, Vec<CliFlag>) {
let host = Host::new();
let cfg = load_bootstrap_config(&bootstrap_config_path(args, ""));
host.apply_config(Arc::new(cfg)).await;
let flags = host.register_command_line_flags(builtin).await;
(host, flags)
}
pub fn with_flags(mut cmd: clap::Command, flags: &[CliFlag]) -> clap::Command {
for flag in flags {
if flag.name == "version" {
cmd = cmd.disable_version_flag(true);
}
let action = if flag.kind == "bool" {
ArgAction::SetTrue
} else {
ArgAction::Set
};
let leak = |s: String| -> &'static str { Box::leak(s.into_boxed_str()) };
cmd = cmd.arg(
clap::Arg::new(leak(format!("plugin:{}", flag.name)))
.long(leak(flag.name.clone()))
.help(leak(flag.usage.clone()))
.action(action),
);
}
cmd
}
pub fn builtin_values(cmd: &clap::Command, matches: &clap::ArgMatches) -> Vec<(String, String)> {
cmd.get_arguments()
.filter(|arg| !arg.get_id().as_str().starts_with("plugin:"))
.filter_map(|arg| {
let name = arg.get_long()?;
if matches!(name, "help" | "version" | "log-file" | "working-dir") {
return None;
}
let id = arg.get_id().as_str();
let value = match arg.get_action() {
ArgAction::SetTrue => matches.get_flag(id).to_string(),
ArgAction::Append => String::new(),
_ => {
if let Ok(Some(v)) = matches.try_get_one::<String>(id) {
v.clone()
} else if let Ok(Some(v)) = matches.try_get_one::<i64>(id) {
v.to_string()
} else if let Ok(Some(v)) = matches.try_get_one::<u16>(id) {
v.to_string()
} else {
String::new()
}
}
};
Some((name.to_owned(), value))
})
.collect()
}
pub async fn execute(host: &Host, config_path: &Path, builtin: &[(String, String)]) -> Option<i32> {
if !host.has_triggered_command_line_flags() {
return None;
}
let raw: Vec<String> = std::env::args().collect();
let program = raw.first().cloned().unwrap_or_default();
let auth_dir = host.host_config_summary().auth_dir;
let persist = |auth: cpa_plugin::auth::PluginAuth| auth.save_file(&auth_dir, false);
let (code, handled, output) = host
.execute_command_line(
&program,
raw.get(1..).unwrap_or_default(),
&config_path.to_string_lossy(),
builtin,
&persist,
)
.await;
for item in output {
let written = match item {
Output::Stdout(data) => std::io::stdout()
.write_all(&data)
.and_then(|()| std::io::stdout().flush()),
Output::Stderr(data) => std::io::stderr().write_all(&data),
};
if let Err(e) = written {
tracing::warn!("pluginhost: failed to write command-line plugin output: {e}");
}
}
handled.then_some(code)
}
#[cfg(test)]
mod tests {
use super::*;
fn args(list: &[&str]) -> Vec<String> {
list.iter().map(|s| s.to_string()).collect()
}
#[test]
fn bootstrap_path_scans_like_go() {
assert_eq!(
bootstrap_config_path(&args(&["x", "-config", "a.yaml"]), "d"),
PathBuf::from("a.yaml")
);
assert_eq!(
bootstrap_config_path(&args(&["--config=b.yaml"]), "d"),
PathBuf::from("b.yaml")
);
assert_eq!(bootstrap_config_path(&args(&["-config"]), "d"), PathBuf::from("d"));
assert_eq!(
bootstrap_config_path(&args(&["--", "-config", "a"]), "d"),
PathBuf::from("d")
);
assert_eq!(
bootstrap_config_path(&args(&["-config", "-tui"]), "d"),
PathBuf::from("-tui")
);
assert_eq!(bootstrap_config_path(&args(&["---config=c"]), "d"), PathBuf::from("d"));
}
}