Resolve symlinks for cargo and xargo home.

Resolve symlinks for the xargo and cargo home (as well as the Nix store) prior to mounting, since they are mounted at a fixed location anyway. This is because podman mounts symlinks as root by default. We always canonicalize the paths on the host, after creating them, to ensure that any symlinks are resolved.

Say we have `/path/to/home`, and `/path/to` is a symlink but `/path/to/home` doesn't exist yet. Trying to canonicalize `/path/to/home/.xargo` will fail, and will still be a symlink if we maybe canonicalize before. First creating the directories and canonicalizing them on the host should always work.

Change the mount points from `/cargo`, `/xargo`, and `/rust` to the same paths as on the host, which avoids unnecessary recompilation when `cargo` and `cross` are intermittently used.

.changes/947.json

@@ -0,0 +1,12 @@
+[
+    {
+        "type": "internal",
+        "description": "resolve symlinks to cargo and xargo home before mounting",
+        "issues": [373]
+    },
+    {
+        "type": "fixed",
+        "description": "mount cargo, xargo, and the sysroot at the same path as on the host to avoid unnecessary recompilation.",
+        "issues": [551]
+    }
+]

src/bin/commands/containers.rs

@@ -451,23 +451,22 @@ pub fn create_persistent_volume(
     docker::remote::copy_volume_container_xargo(
         engine,
         &container,
-        &dirs.xargo,
-        &toolchain_host,
+        &dirs,
         mount_prefix.as_ref(),
         msg_info,
     )?;
     docker::remote::copy_volume_container_cargo(
         engine,
         &container,
-        &dirs.cargo,
+        &dirs,
         mount_prefix.as_ref(),
         copy_registry,
         msg_info,
     )?;
     docker::remote::copy_volume_container_rust(
         engine,
         &container,
-        &toolchain,
+        &dirs,
         None,
         mount_prefix.as_ref(),
         msg_info,

src/docker/image.rs

@@ -135,6 +135,12 @@ impl ImagePlatform {
     }
 }
 
+impl Default for ImagePlatform {
+    fn default() -> ImagePlatform {
+        ImagePlatform::DEFAULT
+    }
+}
+
 impl TryFrom<&str> for ImagePlatform {
     type Error = <Self as std::str::FromStr>::Err;
 

src/docker/local.rs

@@ -27,7 +27,13 @@ pub(crate) fn run(
         .image
         .platform
         .specify_platform(&options.engine, &mut docker);
-    docker_envvars(&mut docker, &options.config, &options.target, msg_info)?;
+    docker_envvars(
+        &mut docker,
+        &options.config,
+        dirs,
+        &options.target,
+        msg_info,
+    )?;
 
     docker_mount(
         &mut docker,
@@ -44,18 +50,28 @@ pub(crate) fn run(
     docker_user_id(&mut docker, engine.kind);
 
     docker
-        .args(&["-v", &format!("{}:/xargo:Z", dirs.xargo.to_utf8()?)])
-        .args(&["-v", &format!("{}:/cargo:Z", dirs.cargo.to_utf8()?)])
+        .args(&[
+            "-v",
+            &format!("{}:{}:Z", dirs.xargo.to_utf8()?, dirs.xargo_mount_path()),
+        ])
+        .args(&[
+            "-v",
+            &format!("{}:{}:Z", dirs.cargo.to_utf8()?, dirs.cargo_mount_path()),
+        ])
         // Prevent `bin` from being mounted inside the Docker container.
-        .args(&["-v", "/cargo/bin"]);
+        .args(&["-v", &format!("{}/bin", dirs.cargo_mount_path())]);
     docker.args(&[
         "-v",
         &format!("{}:{}:Z", dirs.host_root.to_utf8()?, dirs.mount_root),
     ]);
     docker
         .args(&[
             "-v",
-            &format!("{}:/rust:Z,ro", paths.get_sysroot().to_utf8()?),
+            &format!(
+                "{}:{}:Z,ro",
+                dirs.get_sysroot().to_utf8()?,
+                dirs.sysroot_mount_path()
+            ),
         ])
         .args(&["-v", &format!("{}:/target:Z", dirs.target.to_utf8()?)]);
     docker_cwd(&mut docker, &paths)?;
@@ -84,7 +100,7 @@ pub(crate) fn run(
 
     docker
         .arg(&image_name)
-        .args(&["sh", "-c", &format!("PATH=$PATH:/rust/bin {:?}", cmd)])
+        .args(&["sh", "-c", &build_command(dirs, &cmd)])
         .run_and_get_status(msg_info, false)
         .map_err(Into::into)
 }