feat: Parse Cargo's --manifest-path option to determine mounted docker root

CHANGELOG.md

@@ -5,6 +5,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- #494 - Parse Cargo's --manifest-path option to determine mounted docker root
 - Change rust edition to 2021 and bump MSRV for the cross binary to 1.58.1
 - #654 - Use color-eyre for error reporting
 - #658 - Upgrade dependencies

README.md

@@ -354,6 +354,9 @@ $ QEMU_STRACE=1 cross run --target aarch64-unknown-linux-gnu
 - path dependencies (in Cargo.toml) that point outside the Cargo project won't
   work because `cross` use docker containers only mounts the Cargo project so
   the container doesn't have access to the rest of the filesystem.
+  However, you may use Cargo's `--manifest-path` option to reference your
+  target crate, executed from a common root directory from which all your
+  dependencies are available.
 
 ## Minimum Supported Rust Version (MSRV)
 

src/cargo.rs

@@ -64,26 +64,35 @@ impl Root {
 }
 
 /// Cargo project root
-pub fn root() -> Result<Option<Root>> {
-    let cd = env::current_dir().wrap_err("couldn't get current directory")?;
-
-    let mut dir = &*cd;
-    loop {
-        let toml = dir.join("Cargo.toml");
-
-        if fs::metadata(&toml).is_ok() {
-            return Ok(Some(Root {
-                path: dir.to_owned(),
-            }));
+pub fn root(manifest_path: Option<PathBuf>) -> Result<Option<Root>> {
+    if let Some(manifest_path) = manifest_path {
+        if !manifest_path.is_file() {
+            eyre::bail!("No manifest found at \"{}\"", manifest_path.display());
         }
+        return Ok(Some(Root {
+            path: manifest_path
+                .parent()
+                .expect("File must have a parent")
+                .to_owned(),
+        }));
+    } else {
+        let cd = env::current_dir().wrap_err("couldn't get current dir")?;
+        let mut dir = &*cd;
+        loop {
+            let toml = dir.join("Cargo.toml");
 
-        match dir.parent() {
-            Some(p) => dir = p,
-            None => break,
+            if fs::metadata(&toml).is_ok() {
+                return Ok(Some(Root {
+                    path: dir.to_owned(),
+                }));
+            }
+            if let Some(p) = dir.parent() {
+                dir = p;
+            } else {
+                break Ok(None);
+            }
         }
     }
-
-    Ok(None)
 }
 
 /// Pass-through mode

src/cli.rs

@@ -13,11 +13,13 @@ pub struct Args {
     pub target: Option<Target>,
     pub target_dir: Option<PathBuf>,
     pub docker_in_docker: bool,
+    pub manifest_path: Option<PathBuf>,
 }
 
 pub fn parse(target_list: &TargetList) -> Args {
     let mut channel = None;
     let mut target = None;
+    let mut manifest_path: Option<PathBuf> = None;
     let mut target_dir = None;
     let mut sc = None;
     let mut all: Vec<String> = Vec::new();
@@ -28,7 +30,21 @@ pub fn parse(target_list: &TargetList) -> Args {
             if arg.is_empty() {
                 continue;
             }
-            if let ("+", ch) = arg.split_at(1) {
+            if arg == "--manifest-path" {
+                all.push(arg);
+                if let Some(m) = args.next() {
+                    let p = PathBuf::from(&m);
+                    all.push(m);
+                    manifest_path = env::current_dir().ok().map(|cwd| cwd.join(p));
+                }
+            } else if arg.starts_with("--manifest-path=") {
+                manifest_path = arg
+                    .split_once('=')
+                    .map(|x| x.1)
+                    .map(PathBuf::from)
+                    .and_then(|p| env::current_dir().ok().map(|cwd| cwd.join(p)));
+                all.push(arg);
+            } else if let ("+", ch) = arg.split_at(1) {
                 channel = Some(ch.to_string());
             } else if arg == "--target" {
                 all.push(arg);
@@ -73,5 +89,6 @@ pub fn parse(target_list: &TargetList) -> Args {
         target,
         target_dir,
         docker_in_docker,
+        manifest_path,
     }
 }

src/docker.rs

@@ -58,6 +58,7 @@ pub fn run(
     args: &[String],
     target_dir: &Option<PathBuf>,
     root: &Root,
+    docker_root: &Path,
     config: &Config,
     uses_xargo: bool,
     sysroot: &Path,
@@ -89,7 +90,7 @@ pub fn run(
     let cargo_dir = mount_finder.find_mount_path(cargo_dir);
     let xargo_dir = mount_finder.find_mount_path(xargo_dir);
     let target_dir = mount_finder.find_mount_path(target_dir);
-    let mount_root = mount_finder.find_mount_path(root);
+    let mount_root = mount_finder.find_mount_path(docker_root);
     let sysroot = mount_finder.find_mount_path(sysroot);
 
     let mut cmd = if uses_xargo {

src/main.rs

@@ -257,7 +257,7 @@ fn run() -> Result<ExitStatus> {
 
     let version_meta =
         rustc_version::version_meta().wrap_err("couldn't fetch the `rustc` version")?;
-    if let Some(root) = cargo::root()? {
+    if let Some(root) = cargo::root(args.manifest_path)? {
         let host = version_meta.host();
 
         if host.is_supported(args.target.as_ref()) {
@@ -358,11 +358,13 @@ fn run() -> Result<ExitStatus> {
                     docker::register(&target, verbose)?
                 }
 
+                let docker_root = env::current_dir()?;
                 return docker::run(
                     &target,
                     &filtered_args,
                     &args.target_dir,
                     &root,
+                    &docker_root,
                     &config,
                     uses_xargo,
                     &sysroot,