add image build command

Author: willcl-ark

src/rust-cli/image.rs

@@ -0,0 +1,155 @@
+use anyhow::anyhow;
+use clap::Subcommand;
+use std::fs;
+use std::process::{Command, Stdio};
+
+#[derive(Subcommand, Debug)]
+pub enum ImageCommand {
+    /// Build bitcoind and bitcoin-cli from <repo>/<branch> as <registry>:<tag>.
+    /// Optionally deploy to remote registry using --action=push, otherwise image is loaded to local registry.
+    Build {
+        #[arg(long)]
+        repo: String,
+        #[arg(long)]
+        branch: String,
+        #[arg(long)]
+        registry: String,
+        #[arg(long)]
+        tag: String,
+        #[arg(long)]
+        build_args: Option<String>,
+        #[arg(long)]
+        arches: Option<String>,
+        #[arg(long)]
+        action: Option<String>,
+    },
+}
+
+const ARCHES: [&str; 3] = ["amd64", "arm64", "armv7"];
+
+fn run_command(command: &str) -> anyhow::Result<bool> {
+    println!("Executing: {}", command);
+    let mut child = Command::new("bash")
+        .arg("-c")
+        .arg(command)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()?;
+
+    let output = child.wait()?;
+
+    if output.success() {
+        Ok(true)
+    } else {
+        Err(anyhow!("Command failed"))
+    }
+}
+
+fn build_image(
+    repo: &String,
+    branch: &String,
+    docker_registry: &String,
+    tag: &String,
+    build_args: &Option<String>,
+    arches: &Option<String>,
+    action: &Option<String>,
+) -> anyhow::Result<()> {
+    let build_args = match build_args {
+        Some(args) => format!("\"{}\"", args),
+        None => "\"--disable-tests --without-gui --disable-bench --disable-fuzz-binary --enable-suppress-external-warnings \"".to_string(),
+    };
+
+    let mut build_arches = vec![];
+    match arches {
+        Some(a) => build_arches.extend(a.split(',').map(String::from)),
+        None => build_arches.push("amd64".to_string()),
+    }
+
+    for arch in &build_arches {
+        if !ARCHES.contains(&arch.as_str()) {
+            println!("Error: {} is not a supported architecture", arch);
+            return Err(anyhow!("Unsupported architecture: {}", arch));
+        }
+    }
+
+    println!("repo={}", repo);
+    println!("branch={}", branch);
+    println!("docker_registry={}", docker_registry);
+    println!("tag={}", tag);
+    println!("build_args={}", build_args);
+    println!("build_arches={:?}", build_arches);
+
+    if !fs::metadata("src/templates")
+        .map(|m| m.is_dir())
+        .unwrap_or(false)
+    {
+        println!("Directory src/templates does not exist.");
+        println!("Please run this script from the project root.");
+        return Err(anyhow!("src/templates directory not found"));
+    }
+
+    let builder_name = "bitcoind-builder";
+    let create_builder_cmd = format!("docker buildx create --name {} --use", builder_name);
+    let creat_builder_res = run_command(&create_builder_cmd);
+    if creat_builder_res.is_err() {
+        let use_builder_cmd = format!("docker buildx use {}", builder_name);
+        run_command(&use_builder_cmd)?;
+    }
+
+    let image_full_name = format!("{}:{}", docker_registry, tag);
+    println!("image_full_name={}", image_full_name);
+
+    let platforms = build_arches
+        .iter()
+        .map(|arch| format!("linux/{}", arch))
+        .collect::<Vec<_>>()
+        .join(",");
+
+    let action = match action {
+        Some(action) => action,
+        None => "load",
+    };
+    let build_command = format!(
+        "docker buildx build --platform {} --build-arg REPO={} --build-arg BRANCH={} --build-arg BUILD_ARGS={} --tag {} --file src/templates/Dockerfile . --{}",
+        platforms, repo, branch, build_args, image_full_name, action
+    );
+
+    println!("Using build_command={}", build_command);
+
+    let res = run_command(&build_command);
+    if res.is_ok() {
+        println!("Build completed");
+    } else {
+        println!("Build failed.");
+    }
+
+    let cleanup_builder_cmd = format!("docker buildx rm {}", builder_name);
+    let cleanup_res = run_command(&cleanup_builder_cmd);
+    if cleanup_res.is_ok() {
+        println!("Buildx builder removed successfully.");
+    } else {
+        println!("Warning: Failed to remove the buildx builder.");
+    }
+
+    match res {
+        Ok(true) => Ok(()),
+        Ok(false) => Err(anyhow!(
+            "Build command failed, but no specific error was provided."
+        )),
+        Err(e) => Err(anyhow!("Build command failed with error: {}", e)),
+    }
+}
+
+pub async fn handle_image_command(command: &ImageCommand) -> anyhow::Result<()> {
+    match command {
+        ImageCommand::Build {
+            repo,
+            branch,
+            registry,
+            tag,
+            build_args,
+            arches,
+            action,
+        } => build_image(repo, branch, registry, tag, build_args, arches, action),
+    }
+}

src/rust-cli/main.rs

@@ -4,20 +4,23 @@ use clap::{Parser, Subcommand};
 mod debug;
 mod general;
 mod graph;
+mod image;
 mod network;
 mod rpc_call;
 mod scenarios;
 mod util;
 use crate::debug::{handle_debug_command, DebugCommand};
 use crate::general::*;
 use crate::graph::{handle_graph_command, GraphCommand};
+use crate::image::{handle_image_command, ImageCommand};
 use crate::network::{handle_network_command, NetworkCommand};
 use crate::scenarios::{handle_scenario_command, ScenarioCommand};
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Cli {
     #[arg(long)]
+    /// The warnet network command corresponds to
     network: Option<String>,
 
     #[command(subcommand)]
@@ -26,46 +29,51 @@ struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Commands {
-    /// Network commands
-    Network {
-        #[command(subcommand)]
-        command: Option<NetworkCommand>,
-    },
-    /// Debug commands [[deprecated]]
+    /// Debug commands (deprecated)
     Debug {
         #[command(subcommand)]
         command: Option<DebugCommand>,
     },
+    /// Fetch the Bitcoin Core debug log from <node> in [network]
+    DebugLog { node: u64 },
     /// Graph commands
     Graph {
         #[command(subcommand)]
         command: Option<GraphCommand>,
     },
-    /// Scenario commands
-    Scenarios {
+    /// Grep combined logs via fluentd using regex <pattern>
+    GrepLogs { pattern: String },
+    /// Build a warnet-ready bitcoind docker image from a github branch
+    Image {
         #[command(subcommand)]
-        command: Option<ScenarioCommand>,
-    },
-    /// Call bitcoin-cli <method> [params] on <node> in [network]
-    Rpc {
-        node: u64,
-        #[arg(allow_hyphen_values=true)]
-        method: String,
-        params: Option<Vec<String>>,
+        command: Option<ImageCommand>,
     },
     /// Call lncli <method> [params] on <node> in [network]
     LnCli {
         node: u64,
         method: String,
         params: Option<Vec<String>>,
     },
-    /// Fetch the Bitcoin Core debug log from <node> in [network]
-    DebugLog { node: u64 },
     /// Fetch messages sent between <node_a> and <node_b> in [network]
     Messages { node_a: u64, node_b: u64 },
-    /// Grep combined logs via fluentd using regex <pattern>
-    GrepLogs { pattern: String },
-    /// Stop warnet
+    /// Network commands
+    Network {
+        #[command(subcommand)]
+        command: Option<NetworkCommand>,
+    },
+    /// Call bitcoin-cli <method> [params] on <node> in [network]
+    Rpc {
+        node: u64,
+        #[arg(allow_hyphen_values = true)]
+        method: String,
+        params: Option<Vec<String>>,
+    },
+    /// Scenario commands
+    Scenarios {
+        #[command(subcommand)]
+        command: Option<ScenarioCommand>,
+    },
+    /// Stop warnet server
     Stop {},
 }
 
@@ -117,6 +125,11 @@ async fn main() -> anyhow::Result<()> {
         Some(Commands::DebugLog { node }) => {
             handle_debug_log_command(node, rpc_params).await?;
         }
+        Some(Commands::Image { command }) => {
+            if let Some(command) = command {
+                handle_image_command(command).await?;
+            }
+        }
         Some(Commands::Messages { node_a, node_b }) => {
             handle_messages_command(node_a, node_b, rpc_params).await?;
         }