use custom_error::custom_error;
use std::borrow::Cow;
use std::error::Error as stdError;
use std::io::{BufRead, BufReader, Lines};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
custom_error! {UnitdStderrParseError
VersionNotFound = "Version string output not found",
BuildSettingsNotFound = "Build settings not found"
}
#[derive(Debug, Clone)]
pub struct UnitdConfigureOptions {
pub version: Cow<'static, str>,
pub all_flags: Cow<'static, str>,
}
impl UnitdConfigureOptions {
pub fn new(unitd_path: &Path) -> Result<UnitdConfigureOptions, Box<dyn stdError>> {
fn parse_configure_settings_from_unitd_stderr_output<B: BufRead>(
lines: &mut Lines<B>,
) -> Result<UnitdConfigureOptions, Box<dyn stdError>> {
const VERSION_PREFIX: &str = "unit version: ";
const CONFIGURED_AS_PREFIX: &str = "configured as ";
const CONFIGURE_PREFIX: &str = "configured as ./configure ";
fn aggregate_parsable_lines(
mut accum: (Option<String>, Option<String>),
line: String,
) -> (Option<String>, Option<String>) {
if line.starts_with(VERSION_PREFIX) {
accum.0 = line.strip_prefix(VERSION_PREFIX).map(|l| l.to_string());
} else if line.starts_with(CONFIGURED_AS_PREFIX) {
accum.1 = line.strip_prefix(CONFIGURE_PREFIX).map(|l| l.to_string());
}
accum
}
let options_lines = lines
.filter_map(|line| line.ok())
.fold((None, None), aggregate_parsable_lines);
if options_lines.0.is_none() {
return Err(Box::new(UnitdStderrParseError::VersionNotFound) as Box<dyn stdError>);
} else if options_lines.1.is_none() {
return Err(Box::new(UnitdStderrParseError::BuildSettingsNotFound) as Box<dyn stdError>);
}
Ok(UnitdConfigureOptions {
version: options_lines.0.unwrap().into(),
all_flags: options_lines.1.unwrap().into(),
})
}
let program = unitd_path.as_os_str();
let child = Command::new(program)
.arg("--version")
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()?;
let output = child.wait_with_output()?;
let err = BufReader::new(&*output.stderr);
parse_configure_settings_from_unitd_stderr_output(&mut err.lines())
}
pub fn has_flag(&self, flag_name: &str) -> bool {
self.all_flags
.split_ascii_whitespace()
.any(|flag| flag.starts_with(format!("--{}", flag_name).as_str()))
}
pub fn get_flag_value(&self, flag_name: &str) -> Option<String> {
self.all_flags
.split_ascii_whitespace()
.find(|flag| flag.starts_with(format!("--{}", flag_name).as_str()))
.and_then(|flag| {
let parts: Vec<&str> = flag.split('=').collect();
if parts.len() >= 2 {
Some(parts[1].to_owned())
} else {
None
}
})
}
pub fn debug_enabled(&self) -> bool {
self.has_flag("debug")
}
pub fn openssl_enabled(&self) -> bool {
self.has_flag("openssl")
}
pub fn prefix_path(&self) -> Option<Box<Path>> {
self.get_flag_value("prefix")
.map(PathBuf::from)
.map(PathBuf::into_boxed_path)
}
fn join_to_prefix_path<S>(&self, sub_path: S) -> Option<Box<Path>>
where
S: Into<String>,
{
self.prefix_path()
.map(|path| path.join(sub_path.into()).into_boxed_path())
}
pub fn default_control_api_socket_address(&self) -> Option<String> {
// If the socket address is specific configured in the configure options, we use
// that. Otherwise, we use the default path as assumed to be unix:$prefix/control.unit.sock.
match self.get_flag_value("control") {
Some(socket_address) => Some(socket_address),
None => {
// Give up if the unitd is compiled with unix sockets disabled
if self.has_flag("no-unix-sockets") {
return None;
}
let socket_path = self.join_to_prefix_path("control.unit.sock");
socket_path.map(|path| format!("unix:{}", path.to_string_lossy()))
}
}
}
pub fn default_pid_path(&self) -> Option<Box<Path>> {
match self.get_flag_value("pid") {
Some(pid_path) => self.join_to_prefix_path(pid_path),
None => self.join_to_prefix_path("unit.pid"),
}
}
pub fn default_log_path(&self) -> Option<Box<Path>> {
match self.get_flag_value("log") {
Some(pid_path) => self.join_to_prefix_path(pid_path),
None => self.join_to_prefix_path("unit.log"),
}
}
pub fn default_modules_directory(&self) -> Option<Box<Path>> {
match self.get_flag_value("modules") {
Some(modules_dir_name) => self.join_to_prefix_path(modules_dir_name),
None => self.join_to_prefix_path("modules"),
}
}
pub fn default_state_directory(&self) -> Option<Box<Path>> {
match self.get_flag_value("state") {
Some(state_dir_name) => self.join_to_prefix_path(state_dir_name),
None => self.join_to_prefix_path("state"),
}
}
pub fn default_tmp_directory(&self) -> Option<Box<Path>> {
match self.get_flag_value("tmp") {
Some(tmp_dir_name) => self.join_to_prefix_path(tmp_dir_name),
None => self.join_to_prefix_path("tmp"),
}
}
pub fn default_user(&self) -> Option<String> {
self.get_flag_value("user").map(String::from)
}
pub fn default_group(&self) -> Option<String> {
self.get_flag_value("group").map(String::from)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::unitd_instance;
use crate::unitd_instance::UNITD_PATH_ENV_KEY;
#[test]
fn can_detect_key() {
let options = UnitdConfigureOptions {
version: Default::default(),
all_flags: Cow::from("--debug --openssl --prefix=/opt/unit"),
};
assert!(options.has_flag("debug"));
assert!(options.has_flag("openssl"));
assert!(options.has_flag("prefix"));
assert!(!options.has_flag("fobar"));
}
#[test]
fn can_get_flag_value_by_key() {
let expected = "/opt/unit";
let options = UnitdConfigureOptions {
version: Default::default(),
all_flags: Cow::from("--debug --openssl --prefix=/opt/unit"),
};
let actual = options.get_flag_value("prefix");
assert_eq!(expected, actual.unwrap())
}
#[test]
fn can_get_prefix_path() {
let expected: Box<Path> = Path::new("/opt/unit").into();
let options = UnitdConfigureOptions {
version: Default::default(),
all_flags: Cow::from("--debug --openssl --prefix=/opt/unit"),
};
let actual = options.prefix_path();
assert_eq!(expected, actual.unwrap())
}
#[test]
fn can_parse_complicated_configure_options() {
let expected: Box<Path> = Path::new("/usr").into();
let options = UnitdConfigureOptions {
version: Default::default(),
all_flags: Cow::from("--prefix=/usr --state=/var/lib/unit --control=unix:/var/run/control.unit.sock --pid=/var/run/unit.pid --log=/var/log/unit.log --tmp=/var/tmp --user=unit --group=unit --tests --openssl --modules=/usr/lib/unit/modules --libdir=/usr/lib/x86_64-linux-gnu --cc-opt='-g -O2 -fdebug-prefix-map=/data/builder/debuild/unit-1.28.0/pkg/deb/debuild/unit-1.28.0=. -specs=/usr/share/dpkg/no-pie-compile.specs -fstack-protector-strong -Wformat -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fPIC' --ld-opt='-Wl,-Bsymbolic-functions -specs=/usr/share/dpkg/no-pie-link.specs -Wl,-z,relro -Wl,-z,now -Wl,--as-needed -pie'
"),
};
let actual = options.prefix_path();
assert_eq!(expected, actual.unwrap())
}
#[test]
fn can_run_unitd() {
let specific_path = std::env::var(UNITD_PATH_ENV_KEY).map_err(|error| Box::new(error) as Box<dyn stdError>);
let unitd_path = unitd_instance::find_executable_path(specific_path);
let config_options = UnitdConfigureOptions::new(&unitd_path.unwrap());
match config_options {
Ok(options) => {
println!("{:?}", options)
}
Err(error) => panic!("{}", error),
};
}
}
