Add support for cargo clean on remote hosts.

Required to patch cross-rs#724 without deleting the entire volume for persistent
data volumes. A few changes were required: the entire `/cross` mount
prefix must be owned by the user so `/cross/target` can be removed.
Next, we use the full path to the mounted target directory, rather than
the symlink, since `cargo clean` would just delete the symlink. Finally,
we've added `cargo clean` to a list of known subcommands, and it only
needs docker if we use a remote host.

src/bin/cross-util.rs

@@ -52,7 +52,7 @@ fn get_container_engine(engine: Option<&str>, verbose: bool) -> cross::Result<do
     } else {
         docker::get_container_engine()?
     };
-    docker::Engine::from_path(engine, verbose)
+    docker::Engine::from_path(engine, None, verbose)
 }
 
 pub fn main() -> cross::Result<()> {

src/cargo.rs

@@ -19,11 +19,20 @@ pub enum Subcommand {
     Clippy,
     Metadata,
     List,
+    Clean,
 }
 
 impl Subcommand {
-    pub fn needs_docker(self) -> bool {
-        !matches!(self, Subcommand::Other | Subcommand::List)
+    pub fn needs_docker(self, is_remote: bool) -> bool {
+        match self {
+            Subcommand::Other | Subcommand::List => false,
+            Subcommand::Clean if !is_remote => false,
+            _ => true,
+        }
+    }
+
+    pub fn needs_host(self, is_remote: bool) -> bool {
+        self == Subcommand::Clean && is_remote
     }
 
     pub fn needs_interpreter(self) -> bool {
@@ -40,6 +49,7 @@ impl<'a> From<&'a str> for Subcommand {
         match s {
             "b" | "build" => Subcommand::Build,
             "c" | "check" => Subcommand::Check,
+            "clean" => Subcommand::Clean,
             "doc" => Subcommand::Doc,
             "r" | "run" => Subcommand::Run,
             "rustc" => Subcommand::Rustc,

src/docker/engine.rs

@@ -25,18 +25,16 @@ pub struct Engine {
 }
 
 impl Engine {
-    pub fn new(verbose: bool) -> Result<Engine> {
+    pub fn new(is_remote: Option<bool>, verbose: bool) -> Result<Engine> {
         let path = get_container_engine()
             .map_err(|_| eyre::eyre!("no container engine found"))
             .with_suggestion(|| "is docker or podman installed?")?;
-        Self::from_path(path, verbose)
+        Self::from_path(path, is_remote, verbose)
     }
 
-    pub fn from_path(path: PathBuf, verbose: bool) -> Result<Engine> {
+    pub fn from_path(path: PathBuf, is_remote: Option<bool>, verbose: bool) -> Result<Engine> {
         let kind = get_engine_type(&path, verbose)?;
-        let is_remote = env::var("CROSS_REMOTE")
-            .map(|s| bool_from_envvar(&s))
-            .unwrap_or_default();
+        let is_remote = is_remote.unwrap_or_else(Self::is_remote);
         Ok(Engine {
             path,
             kind,
@@ -47,6 +45,12 @@ impl Engine {
     pub fn needs_remote(&self) -> bool {
         self.is_remote && self.kind == EngineType::Podman
     }
+
+    pub fn is_remote() -> bool {
+        env::var("CROSS_REMOTE")
+            .map(|s| bool_from_envvar(&s))
+            .unwrap_or_default()
+    }
 }
 
 // determine if the container engine is docker. this fixes issues with

src/docker/remote.rs

@@ -146,6 +146,19 @@ fn is_cachedir(entry: &fs::DirEntry) -> bool {
     }
 }
 
+fn container_path_exists(
+    engine: &Engine,
+    container: &str,
+    path: &Path,
+    verbose: bool,
+) -> Result<bool> {
+    Ok(subcommand(engine, "exec")
+        .arg(container)
+        .args(&["bash", "-c", &format!("[[ -d '{}' ]]", path.as_posix()?)])
+        .run_and_get_status(verbose, true)?
+        .success())
+}
+
 // copy files for a docker volume, for remote host support
 fn copy_volume_files_nocache(
     engine: &Engine,
@@ -329,15 +342,7 @@ pub fn copy_volume_container_rust_triple(
     // or the first run of the target toolchain, we know it doesn't exist.
     let mut skip = false;
     if skip_exists {
-        skip = subcommand(engine, "exec")
-            .arg(container)
-            .args(&[
-                "bash",
-                "-c",
-                &format!("[[ -d '{}' ]]", dst_toolchain.as_posix()?),
-            ])
-            .run_and_get_status(verbose, true)?
-            .success();
+        skip = container_path_exists(engine, container, &dst_toolchain, verbose)?;
     }
     if !skip {
         copy_volume_files(engine, container, &src_toolchain, &dst_rustlib, verbose)?;
@@ -490,9 +495,6 @@ pub(crate) fn run(
 ) -> Result<ExitStatus> {
     let dirs = Directories::create(engine, metadata, cwd, sysroot, docker_in_docker, verbose)?;
 
-    let mut cmd = cargo_safe_command(uses_xargo);
-    cmd.args(args);
-
     let mount_prefix = MOUNT_PREFIX;
 
     // the logic is broken into the following steps
@@ -654,10 +656,7 @@ pub(crate) fn run(
     let mut to_symlink = vec![];
     let target_dir = file::canonicalize(&dirs.target)?;
     let target_dir = if let Ok(relpath) = target_dir.strip_prefix(&dirs.host_root) {
-        // target dir is in the project, just symlink it in
-        let target_dir = mount_root.join(relpath);
-        to_symlink.push((target_dir.clone(), "/target".to_string()));
-        target_dir
+        mount_root.join(relpath)
     } else {
         // outside project, need to copy the target data over
         // only do if we're copying over cached files.
@@ -687,13 +686,43 @@ 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;
+    let target_dir_string = target_dir.to_utf8()?.to_string();
+    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_string.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_string}"));
+            }
+        } else {
+            final_args.push(arg);
+        }
+    }
+    if !has_target_dir {
+        final_args.push("--target-dir".to_string());
+        final_args.push(target_dir_string);
+    }
+    let mut cmd = cargo_safe_command(uses_xargo);
+    cmd.args(final_args);
+
     // 5. create symlinks for copied data
     let mut symlink = vec!["set -e pipefail".to_string()];
     if verbose {
         symlink.push("set -x".to_string());
     }
     symlink.push(format!(
-        "chown -R {uid}:{gid} {mount_prefix}/*",
+        "chown -R {uid}:{gid} {mount_prefix}",
         uid = user_id(),
         gid = group_id(),
     ));
@@ -738,12 +767,15 @@ symlink_recurse \"${{prefix}}\"
         .map_err(Into::into);
 
     // 7. copy data from our target dir back to host
-    subcommand(engine, "cp")
-        .arg("-a")
-        .arg(&format!("{container}:{}", target_dir.as_posix()?))
-        .arg(&dirs.target.parent().unwrap())
-        .run_and_get_status(verbose, false)
-        .map_err::<eyre::ErrReport, _>(Into::into)?;
+    // this might not exist if we ran `clean`.
+    if container_path_exists(engine, &container, &target_dir, verbose)? {
+        subcommand(engine, "cp")
+            .arg("-a")
+            .arg(&format!("{container}:{}", target_dir.as_posix()?))
+            .arg(&dirs.target.parent().unwrap())
+            .run_and_get_status(verbose, false)
+            .map_err::<eyre::ErrReport, _>(Into::into)?;
+    }
 
     status
 }

src/lib.rs

@@ -478,9 +478,13 @@ pub fn run() -> Result<ExitStatus> {
                 filtered_args.push("-Zbuild-std".to_string());
             }
 
-            if target.needs_docker() && args.subcommand.map(|sc| sc.needs_docker()).unwrap_or(false)
-            {
-                let engine = docker::Engine::new(verbose)?;
+            let is_remote = docker::Engine::is_remote();
+            let needs_docker = args
+                .subcommand
+                .map(|sc| sc.needs_docker(is_remote))
+                .unwrap_or(false);
+            if target.needs_docker() && needs_docker {
+                let engine = docker::Engine::new(Some(is_remote), verbose)?;
                 if host_version_meta.needs_interpreter()
                     && needs_interpreter
                     && target.needs_interpreter()
@@ -489,7 +493,7 @@ pub fn run() -> Result<ExitStatus> {
                     docker::register(&engine, &target, verbose)?
                 }
 
-                return docker::run(
+                let status = docker::run(
                     &engine,
                     &target,
                     &filtered_args,
@@ -500,7 +504,14 @@ pub fn run() -> Result<ExitStatus> {
                     verbose,
                     args.docker_in_docker,
                     &cwd,
-                );
+                )?;
+                let needs_host = args
+                    .subcommand
+                    .map(|sc| sc.needs_host(is_remote))
+                    .unwrap_or(false);
+                if !(status.success() && needs_host) {
+                    return Ok(status);
+                }
             }
         }
     }

xtask/src/main.rs

@@ -93,5 +93,5 @@ fn get_container_engine(engine: Option<&str>, verbose: bool) -> cross::Result<do
     } else {
         docker::get_container_engine()?
     };
-    docker::Engine::from_path(engine, verbose)
+    docker::Engine::from_path(engine, None, verbose)
 }