use std::collections::HashMap;
use std::path::{Path, PathBuf};
#[derive(Debug)]
pub struct BuildContext {
context_dir: PathBuf,
args: HashMap<String, String>,
env: HashMap<String, String>,
target_path: PathBuf,
workdir: PathBuf,
jail_name: String,
verbose: bool,
}
impl BuildContext {
pub fn new(context_dir: &Path, target_path: &Path, jail_name: &str) -> Self {
Self {
context_dir: context_dir.to_path_buf(),
args: HashMap::new(),
env: HashMap::new(),
target_path: target_path.to_path_buf(),
workdir: PathBuf::from("/"),
jail_name: jail_name.to_string(),
verbose: false,
}
}
pub fn verbose(mut self, verbose: bool) -> Self {
self.verbose = verbose;
self
}
pub fn set_arg(&mut self, name: &str, value: &str) {
self.args.insert(name.to_string(), value.to_string());
}
pub fn get_arg(&self, name: &str) -> Option<&str> {
self.args.get(name).map(|s| s.as_str())
}
pub fn set_env(&mut self, name: &str, value: &str) {
self.env.insert(name.to_string(), value.to_string());
}
pub fn env(&self) -> &HashMap<String, String> {
&self.env
}
pub fn set_workdir(&mut self, path: &str) {
self.workdir = PathBuf::from(path);
}
#[allow(dead_code)]
pub fn workdir(&self) -> &Path {
&self.workdir
}
#[allow(dead_code)]
pub fn context_dir(&self) -> &Path {
&self.context_dir
}
pub fn target_path(&self) -> &Path {
&self.target_path
}
pub fn jail_name(&self) -> &str {
&self.jail_name
}
pub fn is_verbose(&self) -> bool {
self.verbose
}
pub fn resolve_source(&self, src: &str) -> PathBuf {
if Path::new(src).is_absolute() {
PathBuf::from(src)
} else {
self.context_dir.join(src)
}
}
pub fn resolve_dest(&self, dest: &str) -> PathBuf {
let path = if Path::new(dest).is_absolute() {
PathBuf::from(dest)
} else {
self.workdir.join(dest)
};
let relative = path.strip_prefix("/").unwrap_or(&path);
self.target_path.join(relative)
}
pub fn substitute(&self, input: &str) -> String {
let mut result = input.to_string();
for (name, value) in &self.args {
result = result.replace(&format!("${{{}}}", name), value);
result = result.replace(&format!("${}", name), value);
}
for (name, value) in &self.env {
result = result.replace(&format!("${{{}}}", name), value);
result = result.replace(&format!("${}", name), value);
}
result = result.replace("${JAIL_NAME}", &self.jail_name);
result = result.replace("$JAIL_NAME", &self.jail_name);
result = result.replace("${WORKDIR}", self.workdir.to_str().unwrap_or("/"));
result = result.replace("$WORKDIR", self.workdir.to_str().unwrap_or("/"));
result
}
pub fn log(&self, message: &str) {
if self.verbose {
println!("[build] {}", message);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_build_context_creation() {
let ctx = BuildContext::new(
Path::new("/build/context"),
Path::new("/jails/test"),
"test",
);
assert_eq!(ctx.context_dir(), Path::new("/build/context"));
assert_eq!(ctx.target_path(), Path::new("/jails/test"));
assert_eq!(ctx.jail_name(), "test");
}
#[test]
fn test_variable_substitution() {
let mut ctx = BuildContext::new(Path::new("/build"), Path::new("/jails/myapp"), "myapp");
ctx.set_arg("VERSION", "1.0");
ctx.set_env("PREFIX", "/usr/local");
assert_eq!(ctx.substitute("version=${VERSION}"), "version=1.0");
assert_eq!(ctx.substitute("prefix=$PREFIX"), "prefix=/usr/local");
assert_eq!(ctx.substitute("jail=${JAIL_NAME}"), "jail=myapp");
}
#[test]
fn test_path_resolution() {
let ctx = BuildContext::new(
Path::new("/build/context"),
Path::new("/jails/test"),
"test",
);
assert_eq!(
ctx.resolve_source("nginx.conf"),
PathBuf::from("/build/context/nginx.conf")
);
assert_eq!(
ctx.resolve_dest("/etc/nginx/nginx.conf"),
PathBuf::from("/jails/test/etc/nginx/nginx.conf")
);
}
#[test]
fn test_workdir() {
let mut ctx = BuildContext::new(Path::new("/build"), Path::new("/jails/test"), "test");
assert_eq!(ctx.workdir(), Path::new("/"));
ctx.set_workdir("/usr/local");
assert_eq!(ctx.workdir(), Path::new("/usr/local"));
assert_eq!(
ctx.resolve_dest("bin/app"),
PathBuf::from("/jails/test/usr/local/bin/app")
);
}
}