wip

Author: Emilgardis

src/bin/commands/install.rs

@@ -0,0 +1,131 @@
+use clap::Args;
+use cross::{docker, rustc, shell::MessageInfo};
+use eyre::Context;
+
+#[derive(Args, Debug)]
+pub struct Install {
+    #[clap(long)]
+    target: Option<String>,
+    /// Provide verbose diagnostic output.
+    #[clap(short, long)]
+    pub verbose: bool,
+    /// Do not print
+    #[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>,
+    /// Path to crate
+    #[clap(long)]
+    pub path: Option<String>,
+    /// Path to Cross.toml
+    #[clap(long)]
+    pub config: Option<std::path::PathBuf>,
+    #[clap(name = "crate")]
+    krate: String,
+}
+
+impl Install {
+    pub fn verbose(&self) -> bool {
+        self.verbose
+    }
+
+    pub fn quiet(&self) -> bool {
+        self.quiet
+    }
+
+    pub fn color(&self) -> Option<&str> {
+        self.color.as_deref()
+    }
+
+    pub fn run(self, msg_info: &mut MessageInfo) -> cross::Result<std::process::ExitStatus> {
+        let target_list = rustc::target_list(&mut cross::shell::Verbosity::Quiet.into())?;
+
+        let host_version_meta = rustc::version_meta()?;
+        let mut command = vec!["install".to_owned(), self.krate];
+
+        if let Some(target) = self.target {
+            command.push(format!("--target={target}"));
+        }
+        if let Some(engine) = self.engine {
+            std::env::set_var(docker::CROSS_CONTAINER_ENGINE_VAR, engine);
+        }
+
+        let args = cross::cli::parse(command, &target_list)?;
+        let Some(cross::CrossSetup {
+            config,
+            target,
+            uses_xargo,
+            uses_zig,
+            uses_build_std,
+            zig_version,
+            toolchain,
+            is_remote,
+            engine,
+            image,
+        }) = cross::setup(&host_version_meta, None, &args, target_list, msg_info)? else {
+            eyre::bail!("couldn't setup context for cross (see warning)")
+        };
+
+        let mut is_nightly = toolchain.channel.contains("nightly");
+        let mut rustc_version = None;
+        if let Some((version, channel, _)) = toolchain.rustc_version()? {
+            is_nightly = channel == rustc_version::Channel::Nightly;
+            rustc_version = Some(version);
+        }
+
+        let available_targets = cross::rustup::setup_rustup(&toolchain, msg_info)?;
+
+        cross::rustup::setup_components(
+            &target,
+            uses_xargo,
+            uses_build_std,
+            &toolchain,
+            is_nightly,
+            available_targets,
+            &args,
+            msg_info,
+        )?;
+
+        let filtered_args = cross::get_filtered_args(
+            zig_version,
+            &args,
+            &target,
+            &config,
+            is_nightly,
+            uses_build_std,
+        );
+
+        let cwd = std::env::current_dir()?;
+
+        let paths =
+            docker::DockerPaths::create(&engine, todo!(), cwd, toolchain.clone(), msg_info)?;
+        let options = docker::DockerOptions::new(
+            engine,
+            target.clone(),
+            config,
+            image,
+            cross::CargoVariant::create(uses_zig, uses_xargo)?,
+            rustc_version,
+        );
+
+        cross::install_interpreter_if_needed(
+            &args,
+            host_version_meta,
+            &target,
+            &options,
+            msg_info,
+        )?;
+
+        let status = docker::run(options, paths, &filtered_args, msg_info)
+            .wrap_err("could not run container")?;
+        let needs_host = args.subcommand.map_or(false, |sc| sc.needs_host(is_remote));
+        if !status.success() {
+            cross::warn_on_failure(&target, &toolchain, msg_info)?;
+        }
+        Ok(status)
+    }
+}

src/bin/commands/mod.rs

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

src/bin/cross-util.rs

@@ -39,6 +39,8 @@ enum Commands {
     Containers(commands::Containers),
     /// Clean all cross data in local storage.
     Clean(commands::Clean),
+    /// Install a binary crate
+    Install(commands::Install),
 }
 
 fn is_toolchain(toolchain: &str) -> cross::Result<Toolchain> {
@@ -103,6 +105,14 @@ pub fn main() -> cross::Result<()> {
             let engine = get_engine!(args, false, msg_info)?;
             args.run(engine, &mut msg_info)?;
         }
+        Commands::Install(args) => {
+            let mut msg_info = get_msg_info!(args)?;
+            let status = args.run(&mut msg_info)?;
+            let code = status
+                .code()
+                .ok_or_else(|| eyre::Report::msg("Cargo process terminated by signal"))?;
+            std::process::exit(code)
+        }
     }
 
     Ok(())

src/bin/cross.rs

@@ -16,7 +16,7 @@ pub fn main() -> cross::Result<()> {
     cross::install_termination_hook()?;
 
     let target_list = rustc::target_list(&mut Verbosity::Quiet.into())?;
-    let args = cli::parse(&target_list)?;
+    let args = cli::parse(env::args().skip(1), &target_list)?;
     let subcommand = args.subcommand;
     let mut msg_info = shell::MessageInfo::create(args.verbose, args.quiet, args.color.as_deref())?;
     let status = match cross::run(args, target_list, &mut msg_info)? {

src/cli.rs

@@ -157,7 +157,7 @@ fn store_target_dir(_: String) -> Result<String> {
     Ok("/target".to_owned())
 }
 
-pub fn parse(target_list: &TargetList) -> Result<Args> {
+pub fn parse(args: impl IntoIterator<Item = String>, target_list: &TargetList) -> Result<Args> {
     let mut channel = None;
     let mut target = None;
     let mut features = Vec::new();
@@ -171,8 +171,9 @@ pub fn parse(target_list: &TargetList) -> Result<Args> {
     let mut verbose = 0;
     let mut color = None;
 
+    let mut args = args.into_iter();
+
     {
-        let mut args = env::args().skip(1);
         while let Some(arg) = args.next() {
             if arg.is_empty() {
                 continue;

src/docker/engine.rs

@@ -11,6 +11,7 @@ use super::{Architecture, ContainerOs};
 
 pub const DOCKER: &str = "docker";
 pub const PODMAN: &str = "podman";
+pub const CROSS_CONTAINER_ENGINE_VAR: &str = "CROSS_CONTAINER_ENGINE";
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum EngineType {
@@ -260,7 +261,7 @@ fn get_custom_info(
 }
 
 pub fn get_container_engine() -> Result<PathBuf, which::Error> {
-    if let Ok(ce) = env::var("CROSS_CONTAINER_ENGINE") {
+    if let Ok(ce) = env::var(CROSS_CONTAINER_ENGINE_VAR) {
         which::which(ce)
     } else {
         which::which(DOCKER).or_else(|_| which::which(PODMAN))

src/lib.rs

@@ -473,7 +473,7 @@ impl CargoVariant {
     }
 }
 
-fn warn_on_failure(
+pub fn warn_on_failure(
     target: &Target,
     toolchain: &QualifiedToolchain,
     msg_info: &mut MessageInfo,
@@ -518,6 +518,8 @@ pub fn run(
 
     let cwd = std::env::current_dir()?;
     if let Some(metadata) = cargo_metadata_with_args(None, Some(&args), msg_info)? {
+        let toml = toml(&metadata, msg_info)?;
+
         let Some(CrossSetup {
             config,
             target,
@@ -529,7 +531,7 @@ pub fn run(
             is_remote,
             engine,
             image,
-        }) = setup(&host_version_meta, &metadata, &args, target_list, msg_info)? else {
+        }) = setup(&host_version_meta, toml, &args, target_list, msg_info)? else {
             return Ok(None);
         };
 
@@ -587,7 +589,7 @@ pub fn run(
             if target.needs_docker() && needs_docker {
                 let paths = docker::DockerPaths::create(
                     &engine,
-                    metadata,
+                    todo!(),
                     cwd,
                     toolchain.clone(),
                     msg_info,
@@ -710,13 +712,12 @@ pub fn get_filtered_args(
 /// Setup cross configuration
 pub fn setup(
     host_version_meta: &rustc_version::VersionMeta,
-    metadata: &CargoMetadata,
+    toml: Option<CrossToml>,
     args: &Args,
     target_list: TargetList,
     msg_info: &mut MessageInfo,
 ) -> Result<Option<CrossSetup>, color_eyre::Report> {
     let host = host_version_meta.host();
-    let toml = toml(metadata, msg_info)?;
     let config = Config::new(toml);
     let target = args
         .target