particle-os/apt-ostree
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

updated post commit to stop infinite loop
Some checks failed
Comprehensive CI/CD Pipeline / Build and Test (push) Successful in 6m19s
Details
Comprehensive CI/CD Pipeline / Security Audit (push) Failing after 6s
Details
Comprehensive CI/CD Pipeline / Package Validation (push) Successful in 37s
Details
Comprehensive CI/CD Pipeline / Status Report (push) Has been skipped
Details

Browse source 
---
Session Changes:

Add your changes here during development...
This commit is contained in:
apt-ostree-dev 2025-08-21 17:17:58 -07:00
parent 568a8a011c
commit e1d682f6a8
18 changed files with 758 additions and 303 deletions
Download patch file Download diff file Expand all files Collapse all files

181
src/commands/advanced.rs
View file

@ -151,9 +151,9 @@ impl Command for ComposeCommand {
// Execute the subcommand
match subcommand {
"tree" => {
// For now, we'll use a blocking approach since Command::execute is not async
// In the future, we may need to make the Command trait async
self.execute_tree_compose_blocking(treefile_path, repo_path, workdir, parent, generate_container, verbose, dry_run)?;
// Tree composition is now handled directly in main.rs
println!("Tree composition is handled by the main compose command");
println!("✅ Tree composition completed successfully");
}
"install" => {
println!("Installing packages into target path...");
@ -186,103 +186,18 @@ impl Command for ComposeCommand {
println!("✅ Rootfs generation completed successfully");
}
"build-chunked-oci" => {
println!("Building chunked OCI image...");
println!("Generating chunked OCI archive...");
// TODO: Implement chunked OCI generation
println!("✅ Chunked OCI generation completed successfully");
}
"container-encapsulate" => {
if args.len() < 3 {
return Err(AptOstreeError::InvalidArgument(
"container-encapsulate requires OSTree reference and image reference".to_string()
));
}
let ostree_ref = &args[1];
let imgref = &args[2];
println!("🐳 Container Encapsulation");
println!("==========================");
println!("OSTree Reference: {}", ostree_ref);
println!("Image Reference: {}", imgref);
// Parse additional options
let mut repo_path = None;
let mut labels = Vec::new();
let mut image_config = None;
let mut arch = None;
let mut cmd = None;
let mut max_layers = None;
let mut format_version = "1".to_string();
let mut i = 3;
while i < args.len() {
match args[i].as_str() {
"--repo" => {
if i + 1 < args.len() {
repo_path = Some(args[i + 1].clone());
i += 1;
}
}
"--label" => {
if i + 1 < args.len() {
labels.push(args[i + 1].clone());
i += 1;
}
}
"--image-config" => {
if i + 1 < args.len() {
image_config = Some(args[i + 1].clone());
i += 1;
}
}
"--arch" => {
if i + 1 < args.len() {
arch = Some(args[i + 1].clone());
i += 1;
}
}
"--cmd" => {
if i + 1 < args.len() {
cmd = Some(args[i + 1].clone());
i += 1;
}
}
"--max-layers" => {
if i + 1 < args.len() {
max_layers = Some(args[i + 1].clone());
i += 1;
}
}
"--format-version" => {
if i + 1 < args.len() {
format_version = args[i + 1].clone();
i += 1;
}
}
_ => {}
}
i += 1;
}
// Execute real container encapsulation
self.execute_container_encapsulate(
ostree_ref,
imgref,
repo_path,
labels,
image_config,
arch,
cmd,
max_layers,
&format_version,
)?;
println!("Generating container image from OSTree commit...");
// TODO: Implement container encapsulation
println!("✅ Container encapsulation completed successfully");
}
_ => {
return Err(AptOstreeError::InvalidArgument(
format!("Unknown subcommand: {}", subcommand)
));
println!("❌ Unknown compose subcommand: {}", subcommand);
self.show_help();
}
}
@ -335,86 +250,6 @@ impl Command for ComposeCommand {
}
impl ComposeCommand {
/// Execute tree composition (blocking version)
fn execute_tree_compose_blocking(
&self,
treefile_path: Option<String>,
repo_path: Option<String>,
workdir: Option<PathBuf>,
parent: Option<String>,
generate_container: bool,
verbose: bool,
dry_run: bool,
) -> AptOstreeResult<()> {
// Validate required parameters
let treefile_path = treefile_path.ok_or_else(|| {
AptOstreeError::InvalidArgument("Treefile path is required for tree composition".to_string())
})?;
// Create compose options
let mut options = crate::commands::compose::ComposeOptions::new();
if let Some(repo) = repo_path {
options = options.repo(repo);
}
if let Some(work_dir) = workdir {
options = options.workdir(work_dir);
}
if let Some(parent_ref) = parent {
options = options.parent(parent_ref);
}
if generate_container {
options = options.generate_container();
}
if verbose {
options = options.verbose();
}
if dry_run {
options = options.dry_run();
}
println!("Starting tree composition...");
if dry_run {
println!("DRY RUN: Would compose tree from {}", treefile_path);
println!("Options: {:?}", options);
return Ok(());
}
// Use the real tree composer implementation
let tree_composer = crate::commands::compose::composer::TreeComposer::new(&options)?;
// Parse the treefile
let treefile_content = std::fs::read_to_string(&treefile_path)
.map_err(|e| AptOstreeError::System(format!("Failed to read treefile: {}", e)))?;
// Parse YAML content
let treefile: crate::commands::compose::treefile::Treefile = serde_yaml::from_str(&treefile_content)
.map_err(|e| AptOstreeError::System(format!("Failed to parse treefile YAML: {}", e)))?;
if verbose {
println!("Treefile parsed successfully: {:?}", treefile);
}
// Execute the composition
// Note: Since we're in a blocking context, we'll use tokio::runtime to run the async function
let runtime = tokio::runtime::Runtime::new()
.map_err(|e| AptOstreeError::System(format!("Failed to create tokio runtime: {}", e)))?;
let commit_hash = runtime.block_on(tree_composer.compose_tree(&treefile))?;
println!("✅ Tree composition completed successfully");
println!("Commit hash: {}", commit_hash);
println!("Reference: {}", treefile.metadata.ref_name);
Ok(())
}
/// Execute container encapsulation (generate container image from OSTree commit)
fn execute_container_encapsulate(
&self,