microsandbox

//! Configuration management for the Microsandbox runtime. //! //! This module provides structures and utilities for modifying Microsandbox //! configuration. use microsandbox_utils::{DEFAULT_SHELL, MICROSANDBOX_CONFIG_FILENAME}; use nondestructive::yaml; use sqlx::{Pool, Sqlite}; use std::{ collections::HashMap, path::{Path, PathBuf}, }; use tokio::fs; use typed_path::Utf8UnixPathBuf; use crate::{ config::{EnvPair, Microsandbox, PathSegment, PortPair, Sandbox}, oci::Reference, MicrosandboxError, MicrosandboxResult, }; use super::db; //-------------------------------------------------------------------------------------------------- // Types //-------------------------------------------------------------------------------------------------- #[derive(Debug, Clone)] /// The component to add to the Microsandbox configuration. pub enum Component { /// A sandbox component. Sandbox { /// The image to use for the sandbox. image: String, /// The amount of memory in MiB to use. memory: Option<u32>, /// The number of CPUs to use. cpus: Option<u32>, /// The volumes to mount. volumes: Vec<String>, /// The ports to expose. ports: Vec<String>, /// The environment variables to use. envs: Vec<String>, /// The environment file to use. env_file: Option<Utf8UnixPathBuf>, /// The dependencies to use for the sandbox. depends_on: Vec<String>, /// The working directory to use for the sandbox. workdir: Option<Utf8UnixPathBuf>, /// The shell to use for the sandbox. shell: Option<String>, /// The scripts to use for the sandbox. scripts: HashMap<String, String>, /// The imports to use for the sandbox. imports: HashMap<String, Utf8UnixPathBuf>, /// The exports to use for the sandbox. exports: HashMap<String, Utf8UnixPathBuf>, /// The network scope to use for the sandbox. scope: Option<String>, }, /// A build component. Build {}, /// A group component. Group {}, } /// The type of component to add to the Microsandbox configuration. #[derive(Debug, Clone)] pub enum ComponentType { /// A sandbox component. Sandbox, /// A build component. Build, /// A group component. Group, } //-------------------------------------------------------------------------------------------------- // Functions //-------------------------------------------------------------------------------------------------- /// Adds one or more components to the Microsandbox configuration. /// /// Modifies the Microsandbox configuration file by adding new components while preserving /// the existing formatting and structure. /// /// ## Arguments /// /// * `names` - Names for the components to add /// * `component` - The component specification to add /// * `project_dir` - Optional project directory path (defaults to current directory) /// * `config_file` - Optional config file path (defaults to standard filename) /// /// ## Returns /// /// * `Ok(())` on success, or error if the file cannot be found/read/written, /// contains invalid YAML, or a component with the same name already exists pub async fn add( names: &[String], component: &Component, project_dir: Option<&Path>, config_file: Option<&str>, ) -> MicrosandboxResult<()> { let (_, _, full_config_path) = resolve_config_paths(project_dir, config_file).await?; // Read the configuration file content let config_contents = fs::read_to_string(&full_config_path).await?; // Parse the YAML document using nondestructive let mut doc = yaml::from_slice(config_contents.as_bytes()) .map_err(|e| MicrosandboxError::ConfigParseError(e.to_string()))?; for name in names { match component { Component::Sandbox { image, memory, cpus, volumes, ports, envs, env_file, depends_on, workdir, shell, scripts, imports, exports, scope, } => { let doc_mut = doc.as_mut(); let mut root_mapping = doc_mut.make_mapping(); // Ensure the "sandboxes" key exists in the root mapping let mut sandboxes_mapping = if let Some(sandboxes_mut) = root_mapping.get_mut("sandboxes") { // Get the existing sandboxes mapping sandboxes_mut.make_mapping() } else { // Create a new sandboxes mapping if it doesn't exist root_mapping .insert("sandboxes", yaml::Separator::Auto) .make_mapping() }; // Check if the sandbox already exists by trying to get it if sandboxes_mapping.get_mut(name).is_some() { return Err(MicrosandboxError::ConfigValidation(format!( "Sandbox with name '{}' already exists", name ))); } // Create a new sandbox mapping let mut sandbox_mapping = sandboxes_mapping .insert(name, yaml::Separator::Auto) .make_mapping(); // Add image field (required) sandbox_mapping.insert_str("image", image.to_string()); // Add optional fields if let Some(memory_value) = memory { sandbox_mapping.insert_u32("memory", *memory_value); } if let Some(cpus_value) = cpus { sandbox_mapping.insert_u32("cpus", *cpus_value as u32); } // Add shell (default if not provided) if let Some(shell_value) = shell { sandbox_mapping.insert_str("shell", shell_value); } else if sandbox_mapping.get_mut("shell").is_none() { sandbox_mapping.insert_str("shell", DEFAULT_SHELL); } // Add volumes if any if !volumes.is_empty() { let mut volumes_sequence = sandbox_mapping .insert("volumes", yaml::Separator::Auto) .make_sequence(); for volume in volumes { volumes_sequence.push_string(volume); } } // Add ports if any if !ports.is_empty() { let mut ports_sequence = sandbox_mapping .insert("ports", yaml::Separator::Auto) .make_sequence(); for port in ports { ports_sequence.push_string(port); } } // Add env vars if any if !envs.is_empty() { let mut envs_sequence = sandbox_mapping .insert("envs", yaml::Separator::Auto) .make_sequence(); for env in envs { envs_sequence.push_string(env); } } // Add env_file if provided if let Some(env_file_path) = env_file { sandbox_mapping.insert_str("env_file", env_file_path.to_string()); } // Add depends_on if any if !depends_on.is_empty() { let mut depends_on_sequence = sandbox_mapping .insert("depends_on", yaml::Separator::Auto) .make_sequence(); for dep in depends_on { depends_on_sequence.push_string(dep); } } // Add workdir if provided if let Some(workdir_path) = workdir { sandbox_mapping.insert_str("workdir", workdir_path.to_string()); } // Add scripts if any if !scripts.is_empty() { let mut scripts_mapping = sandbox_mapping .insert("scripts", yaml::Separator::Auto) .make_mapping(); for (script_name, script_content) in scripts { scripts_mapping.insert_str(script_name, script_content); } } // Add imports if any if !imports.is_empty() { let mut imports_mapping = sandbox_mapping .insert("imports", yaml::Separator::Auto) .make_mapping(); for (import_name, import_path) in imports { imports_mapping.insert_str(import_name, import_path.to_string()); } } // Add exports if any if !exports.is_empty() { let mut exports_mapping = sandbox_mapping .insert("exports", yaml::Separator::Auto) .make_mapping(); for (export_name, export_path) in exports { exports_mapping.insert_str(export_name, export_path.to_string()); } } // Add network scope if provided if let Some(scope_value) = scope { let mut network_mapping = sandbox_mapping .insert("network", yaml::Separator::Auto) .make_mapping(); network_mapping.insert_str("scope", scope_value); } } Component::Build {} => {} Component::Group {} => {} } } // Write the modified YAML back to the file, preserving formatting let modified_content = doc.to_string(); // TODO: Validate config before writing fs::write(full_config_path, modified_content).await?; Ok(()) } /// Removes a component from the Microsandbox configuration. /// /// Modifies the Microsandbox configuration file by removing an existing component /// while preserving the existing formatting and structure. /// /// ## Arguments /// /// * `component` - The component to remove from the configuration /// /// ## Returns /// /// * `Ok(())` on success, or error if the file cannot be found/read/written, /// contains invalid YAML, or the component does not exist /// /// Note: This function is currently a placeholder and needs to be implemented. pub async fn remove( component_type: ComponentType, names: &[String], project_dir: Option<&Path>, config_file: Option<&str>, ) -> MicrosandboxResult<()> { let (_, _, full_config_path) = resolve_config_paths(project_dir, config_file).await?; // Read the configuration file content let config_contents = fs::read_to_string(&full_config_path).await?; let mut doc = yaml::from_slice(config_contents.as_bytes()) .map_err(|e| MicrosandboxError::ConfigParseError(e.to_string()))?; match component_type { ComponentType::Sandbox => { let doc_mut = doc.as_mut(); let mut root_mapping = doc_mut .into_mapping_mut() .ok_or(MicrosandboxError::ConfigParseError( "config is not valid. expected an object".to_string(), ))?; // Ensure the "sandboxes" key exists in the root mapping let mut sandboxes_mapping = if let Some(sandboxes_mut) = root_mapping.get_mut("sandboxes") { // Get the existing sandboxes mapping sandboxes_mut .into_mapping_mut() .ok_or(MicrosandboxError::ConfigParseError( "sandboxes is not a valid mapping".to_string(), ))? } else { // Create a new sandboxes mapping if it doesn't exist root_mapping .insert("sandboxes", yaml::Separator::Auto) .make_mapping() }; for name in names { sandboxes_mapping.remove(name); } } _ => (), } // Write the modified YAML back to the file, preserving formatting let modified_content = doc.to_string(); // TODO: Validate config before writing fs::write(full_config_path, modified_content).await?; Ok(()) } /// Lists components in the Microsandbox configuration. /// /// Retrieves and displays information about components defined in the Microsandbox configuration. /// /// ## Arguments /// /// * `component_type` - The type of component to list /// * `project_dir` - Optional path to the project directory. If None, defaults to current directory /// * `config_file` - Optional path to the Microsandbox config file. If None, uses default filename /// /// ## Returns /// /// * `Ok(())` on success, or error if the file cannot be found/read/written, /// contains invalid YAML, or the component does not exist pub async fn list( component_type: ComponentType, project_dir: Option<&Path>, config_file: Option<&str>, ) -> MicrosandboxResult<Vec<String>> { let (config, _, _) = load_config(project_dir, config_file).await?; match component_type { ComponentType::Sandbox => { return Ok(config.get_sandboxes().keys().cloned().collect()); } _ => return Ok(vec![]), } } //-------------------------------------------------------------------------------------------------- // Functions: Helpers //-------------------------------------------------------------------------------------------------- /// Loads a Microsandbox configuration from a file. /// /// This function handles all the common steps for loading a Microsandbox configuration, including: /// - Resolving the project directory and config file path /// - Validating the config file path /// - Checking if the config file exists /// - Reading and parsing the config file /// /// ## Arguments /// /// * `project_dir` - Optional path to the project directory. If None, defaults to current directory /// * `config_file` - Optional path to the Microsandbox config file. If None, uses default filename /// /// ## Returns /// /// Returns a tuple containing: /// - The loaded Microsandbox configuration /// - The canonical project directory path /// - The config file name /// /// Or a `MicrosandboxError` if: /// - The config file path is invalid /// - The config file does not exist /// - The config file cannot be read /// - The config file contains invalid YAML pub async fn load_config( project_dir: Option<&Path>, config_file: Option<&str>, ) -> MicrosandboxResult<(Microsandbox, PathBuf, String)> { // Get the target path, defaulting to current directory if none specified let project_dir = project_dir.unwrap_or_else(|| Path::new(".")); let canonical_project_dir = fs::canonicalize(project_dir).await?; // Validate the config file path let config_file = config_file.unwrap_or_else(|| MICROSANDBOX_CONFIG_FILENAME); let _ = PathSegment::try_from(config_file)?; let full_config_path = canonical_project_dir.join(config_file); // Check if config file exists if !full_config_path.exists() { return Err(MicrosandboxError::MicrosandboxConfigNotFound( project_dir.display().to_string(), )); } // Read and parse the config file let config_contents = fs::read_to_string(&full_config_path).await?; let config: Microsandbox = serde_yaml::from_str(&config_contents)?; Ok((config, canonical_project_dir, config_file.to_string())) } /// Resolves the paths for a Microsandbox configuration. /// /// This function is similar to `load_config` but without actually loading the file. /// It just resolves the paths that would be used. /// /// ## Arguments /// /// * `project_dir` - Optional path to the project directory. If None, defaults to current directory /// * `config_file` - Optional path to the Microsandbox config file. If None, uses default filename /// /// ## Returns /// /// Returns a tuple containing: /// - The canonical project directory path /// - The config file name /// - The full config file path pub async fn resolve_config_paths( project_dir: Option<&Path>, config_file: Option<&str>, ) -> MicrosandboxResult<(PathBuf, String, PathBuf)> { // Get the target path, defaulting to current directory if none specified let project_dir = project_dir.unwrap_or_else(|| Path::new(".")); let canonical_project_dir = fs::canonicalize(project_dir).await?; // Validate the config file path let config_file = config_file.unwrap_or_else(|| MICROSANDBOX_CONFIG_FILENAME); let _ = PathSegment::try_from(config_file)?; let full_config_path = canonical_project_dir.join(config_file); // Check if config file exists if !full_config_path.exists() { return Err(MicrosandboxError::MicrosandboxConfigNotFound( project_dir.display().to_string(), )); } Ok(( canonical_project_dir, config_file.to_string(), full_config_path, )) } /// Applies defaults from an OCI image configuration to a sandbox configuration. /// /// This function enhances the sandbox configuration with defaults from the OCI image /// configuration when they are not explicitly defined in the sandbox config. /// /// The following defaults are applied: /// - Script: Uses the entrypoint and cmd from the image if a script is missing /// - Environment variables: Combines image env variables with sandbox env variables /// - Working directory: Uses the image's working directory if not specified /// - Exposed ports: Combines image exposed ports with sandbox ports /// /// ## Arguments /// /// * `sandbox_config` - Mutable reference to the sandbox configuration to enhance /// * `reference` - OCI image reference to get defaults from /// * `script_name` - The name of the script we're trying to run /// /// ## Returns /// /// Returns `Ok(())` if defaults were successfully applied, or a `MicrosandboxError` if: /// - The image configuration could not be retrieved /// - Any conversion or parsing operations fail pub async fn apply_image_defaults( sandbox_config: &mut Sandbox, reference: &Reference, oci_db: &Pool<Sqlite>, ) -> MicrosandboxResult<()> { // Get the image configuration if let Some(config) = db::get_image_config(&oci_db, &reference.to_string()).await? { tracing::info!("applying defaults from image configuration"); // Apply working directory if not set in sandbox if sandbox_config.get_workdir().is_none() && config.config_working_dir.is_some() { let workdir = config.config_working_dir.unwrap(); tracing::debug!("using image working directory: {}", workdir); let workdir_path = Utf8UnixPathBuf::from(workdir); sandbox_config.workdir = Some(workdir_path); } // Combine environment variables if let Some(config_env_json) = config.config_env_json { if let Ok(image_env_vars) = serde_json::from_str::<Vec<String>>(&config_env_json) { let mut image_env_pairs = Vec::new(); for env_var in image_env_vars { if let Ok(env_pair) = env_var.parse::<EnvPair>() { image_env_pairs.push(env_pair); } } tracing::debug!("image env vars: {:#?}", image_env_pairs); // Combine image env vars with sandbox env vars (image vars come first) let mut combined_env = image_env_pairs; combined_env.extend_from_slice(sandbox_config.get_envs()); sandbox_config.envs = combined_env; } } // Apply entrypoint and cmd as command if no command is defined if sandbox_config.get_command().is_empty() { let mut command_vec: Vec<String> = Vec::new(); let mut has_entrypoint_or_cmd = false; // Try to use entrypoint and cmd from image config if let Some(entrypoint_json) = &config.config_entrypoint_json { if let Ok(entrypoint) = serde_json::from_str::<Vec<String>>(entrypoint_json) { if !entrypoint.is_empty() { has_entrypoint_or_cmd = true; command_vec = entrypoint; // Add CMD args if they exist if let Some(cmd_json) = &config.config_cmd_json { if let Ok(cmd) = serde_json::from_str::<Vec<String>>(cmd_json) { if !cmd.is_empty() { command_vec.extend(cmd); } } } tracing::debug!("entrypoint exec content: {:?}", command_vec); } } } else if let Some(cmd_json) = &config.config_cmd_json { if let Ok(cmd) = serde_json::from_str::<Vec<String>>(cmd_json) { if !cmd.is_empty() { has_entrypoint_or_cmd = true; command_vec = cmd; tracing::debug!("cmd exec content: {:?}", command_vec); } } } // If we found an entrypoint or cmd, set it as the command if has_entrypoint_or_cmd { tracing::debug!("setting command to: {:?}", command_vec); sandbox_config.command = command_vec; } else if let Some(shell_value) = &sandbox_config.shell { // If no entrypoint or cmd, use shell as fallback command tracing::debug!("using shell as fallback command"); sandbox_config.command = vec![shell_value.clone()]; } } // Combine exposed ports if let Some(exposed_ports_json) = &config.config_exposed_ports_json { if let Ok(exposed_ports_map) = serde_json::from_str::<serde_json::Value>(exposed_ports_json) { if let Some(exposed_ports_obj) = exposed_ports_map.as_object() { let mut additional_ports = Vec::new(); for port_key in exposed_ports_obj.keys() { // Port keys in OCI format are like "80/tcp" if let Some(container_port) = port_key.split('/').next() { if let Ok(port_num) = container_port.parse::<u16>() { // Create a port mapping from host port to container port // We'll use the same port on both sides let port_pair = format!("{}:{}", port_num, port_num).parse::<PortPair>(); if let Ok(port_pair) = port_pair { // Only add if not already defined in sandbox config let existing_ports = sandbox_config.get_ports(); if !existing_ports .iter() .any(|p| p.get_guest() == port_pair.get_guest()) { additional_ports.push(port_pair); } } } } } tracing::debug!("additional ports: {:?}", additional_ports); // Add new ports to existing ones let mut combined_ports = sandbox_config.get_ports().to_vec(); combined_ports.extend(additional_ports); sandbox_config.ports = combined_ports; } } } } Ok(()) }