Merge #1054

1054: Allow Persistent Data Volume to be Created Outside of Package r=Emilgardis a=Alexhuszagh

This changes the unique container IDs to be based off the toolchain ID, the host target name, the hash of the current working directory, the system time. This means it will be fully unique at the millisecond resolution. This also separated package and toolchain directories. Toolchain directories are the only ones required when creating persistent data volumes, while running cross requires both. There are no backwards incompatible changes, since the persistent data volumes stay the same.

Closes #1045.

Co-authored-by: Alex Huszagh <ahuszagh@gmail.com>

Author: bors[bot]

.changes/1054.json

@@ -0,0 +1,4 @@
+{
+    "type": "internal",
+    "description": "change the unique container ID to be unique based off the toolchain and system time."
+}

src/bin/commands/containers.rs

@@ -395,10 +395,10 @@ pub fn create_persistent_volume(
     if let Some(channel) = channel {
         toolchain.channel = channel.channel.clone();
     };
-    let (dirs, metadata) = docker::get_package_info(engine, toolchain.clone(), msg_info)?;
-    let container =
-        docker::remote::unique_container_identifier(&toolchain.host().target, &metadata, &dirs)?;
-    let volume = dirs.toolchain.unique_toolchain_identifier()?;
+    let mount_finder = docker::MountFinder::create(engine)?;
+    let dirs = docker::ToolchainDirectories::assemble(&mount_finder, toolchain.clone())?;
+    let container = dirs.unique_container_identifier(&toolchain.host().target)?;
+    let volume = dirs.unique_toolchain_identifier()?;
 
     if docker::remote::volume_exists(engine, &volume, msg_info)? {
         eyre::bail!("Error: volume {volume} already exists.");
@@ -482,8 +482,9 @@ pub fn remove_persistent_volume(
     if let Some(channel) = channel {
         toolchain.channel = channel.channel.clone();
     };
-    let (dirs, _) = docker::get_package_info(engine, toolchain, msg_info)?;
-    let volume = dirs.toolchain.unique_toolchain_identifier()?;
+    let mount_finder = docker::MountFinder::create(engine)?;
+    let dirs = docker::ToolchainDirectories::assemble(&mount_finder, toolchain)?;
+    let volume = dirs.unique_toolchain_identifier()?;
 
     if !docker::remote::volume_exists(engine, &volume, msg_info)? {
         eyre::bail!("Error: volume {volume} does not exist.");

src/docker/local.rs

@@ -26,7 +26,8 @@ pub(crate) fn run(
     msg_info: &mut MessageInfo,
 ) -> Result<ExitStatus> {
     let engine = &options.engine;
-    let dirs = &paths.directories;
+    let toolchain_dirs = paths.directories.toolchain_directories();
+    let package_dirs = paths.directories.package_directories();
 
     let mut cmd = cargo_safe_command(options.cargo_variant);
     cmd.args(args);
@@ -38,7 +39,7 @@ pub(crate) fn run(
         .image
         .platform
         .specify_platform(&options.engine, &mut docker);
-    docker_envvars(&mut docker, &options, dirs, msg_info)?;
+    docker_envvars(&mut docker, &options, toolchain_dirs, msg_info)?;
 
     docker_mount(
         &mut docker,
@@ -57,33 +58,48 @@ pub(crate) fn run(
     docker
         .args([
             "-v",
-            &format!("{}:{}:z", dirs.xargo.to_utf8()?, dirs.xargo_mount_path()),
+            &format!(
+                "{}:{}:z",
+                toolchain_dirs.xargo_host_path()?,
+                toolchain_dirs.xargo_mount_path()
+            ),
         ])
         .args([
             "-v",
-            &format!("{}:{}:z", dirs.cargo.to_utf8()?, dirs.cargo_mount_path()),
+            &format!(
+                "{}:{}:z",
+                toolchain_dirs.cargo_host_path()?,
+                toolchain_dirs.cargo_mount_path()
+            ),
         ])
         // Prevent `bin` from being mounted inside the Docker container.
-        .args(["-v", &format!("{}/bin", dirs.cargo_mount_path())]);
+        .args(["-v", &format!("{}/bin", toolchain_dirs.cargo_mount_path())]);
     docker.args([
         "-v",
-        &format!("{}:{}:z", dirs.host_root.to_utf8()?, dirs.mount_root),
+        &format!(
+            "{}:{}:z",
+            package_dirs.host_root().to_utf8()?,
+            package_dirs.mount_root()
+        ),
     ]);
     docker
         .args([
             "-v",
             &format!(
                 "{}:{}:z,ro",
-                dirs.get_sysroot().to_utf8()?,
-                dirs.sysroot_mount_path()
+                toolchain_dirs.get_sysroot().to_utf8()?,
+                toolchain_dirs.sysroot_mount_path()
             ),
         ])
-        .args(["-v", &format!("{}:/target:z", dirs.target.to_utf8()?)]);
+        .args([
+            "-v",
+            &format!("{}:/target:z", package_dirs.target().to_utf8()?),
+        ]);
     docker_cwd(&mut docker, &paths)?;
 
     // When running inside NixOS or using Nix packaging we need to add the Nix
     // Store to the running container so it can load the needed binaries.
-    if let Some(ref nix_store) = dirs.nix_store {
+    if let Some(nix_store) = toolchain_dirs.nix_store() {
         docker.args([
             "-v",
             &format!(
@@ -106,7 +122,7 @@ pub(crate) fn run(
 
     docker
         .arg(&image_name)
-        .args(["sh", "-c", &build_command(dirs, &cmd)])
+        .args(["sh", "-c", &build_command(toolchain_dirs, &cmd)])
         .run_and_get_status(msg_info, false)
         .map_err(Into::into)
 }