Allow to run arbitrary commands in containers using cross-util run ...

.changes/1280.json

@@ -0,0 +1,6 @@
+{
+  "description": "Allow to run arbitrary commands in containers using `cross-util run ...`",
+  "issues": [1266],
+  "type": "added",
+  "breaking": false
+}

src/bin/commands/mod.rs

@@ -1,7 +1,9 @@
 mod clean;
 mod containers;
 mod images;
+mod run;
 
 pub use self::clean::*;
 pub use self::containers::*;
 pub use self::images::*;
+pub use self::run::*;

src/bin/commands/run.rs

@@ -0,0 +1,116 @@
+use clap::Args as ClapArgs;
+use cross::config::Config;
+use cross::shell::{MessageInfo, Verbosity};
+use cross::{
+    cargo_metadata_with_args, cli::Args, docker, rustc, setup, toml, CommandVariant, CrossSetup,
+    Target,
+};
+use eyre::Context;
+
+#[derive(ClapArgs, Debug)]
+pub struct Run {
+    /// Provide verbose diagnostic output.
+    #[clap(short, long)]
+    pub verbose: bool,
+    /// Do not print cross log messages.
+    #[clap(short, long)]
+    pub quiet: bool,
+    /// Coloring: auto, always, never
+    #[clap(long)]
+    pub color: Option<String>,
+    /// Container engine (such as docker or podman).
+    #[clap(long)]
+    pub engine: Option<String>,
+    /// Target
+    #[clap(short, long)]
+    pub target: String,
+    /// Interactive session
+    #[clap(short, long, default_value = "false")]
+    pub interactive: bool,
+    /// Command to run, will be run in a shell
+    #[clap(last = true)]
+    pub command: String,
+}
+
+impl Run {
+    pub fn run(&self, engine: docker::Engine, msg_info: &mut MessageInfo) -> cross::Result<()> {
+        let target_list = rustc::target_list(&mut Verbosity::Quiet.into())?;
+        let target = Target::from(&self.target, &target_list);
+
+        let cwd = std::env::current_dir()?;
+        let host_version_meta = rustc::version_meta()?;
+
+        let args = Args {
+            cargo_args: vec![],
+            rest_args: vec![],
+            subcommand: None,
+            channel: None,
+            target: Some(target.clone()),
+            features: vec![],
+            target_dir: None,
+            manifest_path: None,
+            version: false,
+            verbose: if self.verbose { 1 } else { 0 },
+            quiet: self.quiet,
+            color: self.color.clone(),
+        };
+
+        if let Some(metadata) = cargo_metadata_with_args(None, Some(&args), msg_info)? {
+            let CrossSetup { toolchain, .. } =
+                match setup(&host_version_meta, &metadata, &args, target_list, msg_info)? {
+                    Some(setup) => setup,
+                    _ => {
+                        eyre::bail!("Error: cannot setup cross environment");
+                    }
+                };
+
+            let toml = toml(&metadata, msg_info)?;
+            let config = Config::new(toml);
+
+            let image = match docker::get_image(&config, &target, false) {
+                Ok(i) => i,
+                Err(err) => {
+                    msg_info.warn(&err)?;
+                    eyre::bail!("Error: {}", &err);
+                }
+            };
+
+            let image = image.to_definite_with(&engine, msg_info);
+
+            let paths = docker::DockerPaths::create(&engine, metadata, cwd, toolchain, msg_info)?;
+            let options = docker::DockerOptions::new(
+                engine,
+                target,
+                config,
+                image,
+                CommandVariant::Shell,
+                None,
+                self.interactive,
+            );
+
+            let mut args = vec![String::from("-c")];
+            args.push(self.command.clone());
+
+            docker::run(options, paths, &args, None, msg_info)
+                .wrap_err("could not run container")?;
+        }
+
+        Ok(())
+    }
+
+    pub fn engine(&self) -> Option<&str> {
+        self.engine.as_deref()
+    }
+
+    pub fn verbose(&self) -> bool {
+        self.verbose
+    }
+
+    pub fn quiet(&self) -> bool {
+        self.quiet
+    }
+
+    pub fn color(&self) -> Option<&str> {
+        self.color.as_deref()
+    }
+}

src/bin/cross-util.rs

@@ -37,6 +37,8 @@ enum Commands {
     /// Work with cross containers in local storage.
     #[clap(subcommand)]
     Containers(commands::Containers),
+    /// Run in cross container.
+    Run(commands::Run),
     /// Clean all cross data in local storage.
     Clean(commands::Clean),
 }
@@ -103,6 +105,11 @@ pub fn main() -> cross::Result<()> {
             let engine = get_engine!(args, false, msg_info)?;
             args.run(engine, &mut msg_info)?;
         }
+        Commands::Run(args) => {
+            let mut msg_info = get_msg_info!(args)?;
+            let engine = get_engine!(args, false, msg_info)?;
+            args.run(engine, &mut msg_info)?;
+        }
     }
 
     Ok(())

src/docker/custom.rs

@@ -85,7 +85,7 @@ impl<'a> Dockerfile<'a> {
         build_args: impl IntoIterator<Item = (impl AsRef<str>, impl AsRef<str>)>,
         msg_info: &mut MessageInfo,
     ) -> Result<String> {
-        let uses_zig = options.cargo_variant.uses_zig();
+        let uses_zig = options.command_variant.uses_zig();
         let mut docker_build = options.engine.command();
         docker_build.invoke_build_command();
         docker_build.disable_scan_suggest();

src/docker/image.rs

@@ -27,7 +27,7 @@ pub struct PossibleImage {
 }
 
 impl PossibleImage {
-    pub(crate) fn to_definite_with(&self, engine: &Engine, msg_info: &mut MessageInfo) -> Image {
+    pub fn to_definite_with(&self, engine: &Engine, msg_info: &mut MessageInfo) -> Image {
         if self.toolchain.is_empty() {
             Image {
                 name: self.name.clone(),

src/docker/local.rs

@@ -36,7 +36,7 @@ pub(crate) fn run(
     let toolchain_dirs = paths.directories.toolchain_directories();
     let package_dirs = paths.directories.package_directories();
 
-    let mut cmd = options.cargo_variant.safe_command();
+    let mut cmd = options.command_variant.safe_command();
     cmd.args(args);
 
     let mut docker = engine.subcommand("run");
@@ -134,6 +134,11 @@ pub(crate) fn run(
     if io::Stdin::is_atty() && io::Stdout::is_atty() && io::Stderr::is_atty() {
         docker.arg("-t");
     }
+
+    if options.interactive {
+        docker.arg("-i");
+    }
+
     let mut image_name = options.image.name.clone();
     if options.needs_custom_image() {
         image_name = options

src/docker/remote.rs

@@ -895,34 +895,40 @@ pub(crate) fn run(
         }
     }
 
-    // `clean` doesn't handle symlinks: it will just unlink the target
-    // directory, so we should just substitute it our target directory
-    // for it. we'll still have the same end behavior
-    let mut final_args = vec![];
-    let mut iter = args.iter().cloned();
-    let mut has_target_dir = false;
-    while let Some(arg) = iter.next() {
-        if arg == "--target-dir" {
-            has_target_dir = true;
-            final_args.push(arg);
-            if iter.next().is_some() {
-                final_args.push(target_dir.clone());
-            }
-        } else if arg.starts_with("--target-dir=") {
-            has_target_dir = true;
-            if arg.split_once('=').is_some() {
-                final_args.push(format!("--target-dir={target_dir}"));
+    let mut cmd = options.command_variant.safe_command();
+
+    if !options.command_variant.is_shell() {
+        // `clean` doesn't handle symlinks: it will just unlink the target
+        // directory, so we should just substitute it our target directory
+        // for it. we'll still have the same end behavior
+        let mut final_args = vec![];
+        let mut iter = args.iter().cloned();
+        let mut has_target_dir = false;
+        while let Some(arg) = iter.next() {
+            if arg == "--target-dir" {
+                has_target_dir = true;
+                final_args.push(arg);
+                if iter.next().is_some() {
+                    final_args.push(target_dir.clone());
+                }
+            } else if arg.starts_with("--target-dir=") {
+                has_target_dir = true;
+                if arg.split_once('=').is_some() {
+                    final_args.push(format!("--target-dir={target_dir}"));
+                }
+            } else {
+                final_args.push(arg);
             }
-        } else {
-            final_args.push(arg);
         }
+        if !has_target_dir && subcommand.map_or(true, |s| s.needs_target_in_command()) {
+            final_args.push("--target-dir".to_owned());
+            final_args.push(target_dir.clone());
+        }
+
+        cmd.args(final_args);
+    } else {
+        cmd.args(args);
     }
-    if !has_target_dir && subcommand.map_or(true, |s| s.needs_target_in_command()) {
-        final_args.push("--target-dir".to_owned());
-        final_args.push(target_dir.clone());
-    }
-    let mut cmd = options.cargo_variant.safe_command();
-    cmd.args(final_args);
 
     // 5. create symlinks for copied data
     let mut symlink = vec!["set -e pipefail".to_owned()];
@@ -971,6 +977,11 @@ symlink_recurse \"${{prefix}}\"
     docker.add_cwd(&paths)?;
     docker.arg(&container_id);
     docker.add_build_command(toolchain_dirs, &cmd);
+
+    if options.interactive {
+        docker.arg("-i");
+    }
+
     bail_container_exited!();
     let status = docker
         .run_and_get_status(msg_info, false)

src/docker/shared.rs

@@ -17,7 +17,7 @@ use crate::file::{self, write_file, PathExt, ToUtf8};
 use crate::id;
 use crate::rustc::QualifiedToolchain;
 use crate::shell::{ColorChoice, MessageInfo, Verbosity};
-use crate::{CargoVariant, OutputExt, Target, TargetTriple};
+use crate::{CommandVariant, OutputExt, Target, TargetTriple};
 
 use rustc_version::Version as RustcVersion;
 
@@ -33,9 +33,10 @@ pub struct DockerOptions {
     pub target: Target,
     pub config: Config,
     pub image: Image,
-    pub cargo_variant: CargoVariant,
+    pub command_variant: CommandVariant,
     // not all toolchains will provide this
     pub rustc_version: Option<RustcVersion>,
+    pub interactive: bool,
 }
 
 impl DockerOptions {
@@ -44,16 +45,18 @@ impl DockerOptions {
         target: Target,
         config: Config,
         image: Image,
-        cargo_variant: CargoVariant,
+        cargo_variant: CommandVariant,
         rustc_version: Option<RustcVersion>,
+        interactive: bool,
     ) -> DockerOptions {
         DockerOptions {
             engine,
             target,
             config,
             image,
-            cargo_variant,
+            command_variant: cargo_variant,
             rustc_version,
+            interactive,
         }
     }
 
@@ -928,8 +931,8 @@ fn validate_env_var<'a>(
     Ok((key, value))
 }
 
-impl CargoVariant {
-    pub(crate) fn safe_command(self) -> SafeCommand {
+impl CommandVariant {
+    pub(crate) fn safe_command(&self) -> SafeCommand {
         SafeCommand::new(self.to_str())
     }
 }
@@ -1041,7 +1044,7 @@ impl DockerCommandExt for Command {
             ])
             .args(["-e", "CARGO_TARGET_DIR=/target"])
             .args(["-e", &cross_runner]);
-        if options.cargo_variant.uses_zig() {
+        if options.command_variant.uses_zig() {
             // otherwise, zig has a permission error trying to create the cache
             self.args(["-e", "XDG_CACHE_HOME=/target/.zig-cache"]);
         }
@@ -1271,7 +1274,7 @@ pub fn get_image_name(config: &Config, target: &Target, uses_zig: bool) -> Resul
         .image_name(CROSS_IMAGE, version))
 }
 
-pub(crate) fn get_image(config: &Config, target: &Target, uses_zig: bool) -> Result<PossibleImage> {
+pub fn get_image(config: &Config, target: &Target, uses_zig: bool) -> Result<PossibleImage> {
     if let Some(image) = config.image(target)? {
         return Ok(image);
     }