feat: run use temp sub file

justfile

@@ -0,0 +1,8 @@
+# justfile, build bin file
+
+release:
+  cargo b --release
+
+release-linux:
+  cargo r -- build --release
+

src/docker_util.rs

@@ -15,6 +15,8 @@ pub struct DockerCmd {
     docker_current_dir: Option<String>,
     docker_run_uid: Option<u32>,
     docker_run_gid: Option<u32>,
+    volumns: Vec<(String, String)>,
+    mirror: Option<String>,
 }
 
 impl DockerCmd {
@@ -40,6 +42,16 @@ impl DockerCmd {
         self
     }
 
+    pub fn mirror(&mut self, mirror: &str) -> &mut Self {
+        self.mirror = Some(mirror.into());
+        self
+    }
+
+    pub fn add_volumn(&mut self, outer_vol: &str, docker_vol: &str) -> &mut Self {
+        self.volumns.push((outer_vol.into(), docker_vol.into()));
+        self
+    }
+
     pub fn exec(self, cmds: &[String]) -> XResult<()> {
         let mut cmd = Command::new(DOCKER_CMD);
         cmd.arg("run");
@@ -51,6 +63,10 @@ impl DockerCmd {
         ));
         cmd.arg("-v");
         cmd.arg(&format!("{}:/usr/src/app", build_util::get_work_dir(&self.docker_current_dir)?));
+        for (outer_vol, docker_vol) in self.volumns {
+            cmd.arg("-v");
+            cmd.arg(&format!("{}:{}", outer_vol, docker_vol));
+        }
         cmd.arg("-w");
         cmd.arg("/usr/src/app");
         cmd.arg(&self.docker_name);
@@ -63,20 +79,58 @@ impl DockerCmd {
             },
         };
 
+        let mut sub_cmd = String::new();
+        if let Some(mirror) = self.mirror {
+            sub_cmd.push_str(&make_cmd(&mirror));
+            sub_cmd.push_str("\n");
+        }
+
+        let mut builder_cmd = builder_name;
+        let mut sub_build_cmd = vec![];
         let mut cmds_iter = cmds.iter();
         if let Some(cmd0) = cmds_iter.next() {
             if cmd0.starts_with(":") {
-                cmd.arg(&cmd0.chars().skip(1).collect::<String>());
+                builder_cmd = cmd0.chars().skip(1).collect::<String>();
             } else {
-                cmd.arg(&builder_name);
-                cmd.arg(&cmd0);
+                sub_build_cmd.push(cmd0.clone());
             }
         } else {
-            cmd.arg(&builder_name);
+            warning!("Docker build param is empty!");
         }
-        cmds_iter.for_each(|c| { cmd.arg(c); });
+        cmds_iter.for_each(|c| { sub_build_cmd.push(c.clone()); });
+
+        sub_cmd.push_str(&builder_cmd);
+        sub_cmd.push(' ');
+        sub_cmd.push_str(&sub_build_cmd.iter().map(|cmd| {
+            let mut r = String::new();
+            r.push('\'');
+            for c in cmd.chars() {
+                if c == '\'' {
+                    r.push('\\');
+                }
+                r.push(c);
+            }
+            r.push('\'');
+            r
+        }).collect::<Vec<_>>().join(" "));
+
+        std::fs::write("temp_sub_cmd", &sub_cmd).ok();
+
+        cmd.args(vec!["bash", "temp_sub_cmd"]);
+
         information!("Docker cmd exec: {:?}", cmd);
+        information!("Docker temp sub cmd: {}", sub_cmd);
         util_cmd::run_command_and_wait(&mut cmd).map_err(|e| e.into())
-        // Ok(())
     }
 }
+
+fn make_cmd(mirror: &str) -> String {
+    let mut s = String::new();
+    s.push_str(&format!(r#"echo '[source.crates-io]
+    registry = "https://github.com/rust-lang/crates.io-index"
+    replace-with = "mirror"
+    [source.mirror]
+    registry = "{}"
+    ' > /usr/local/cargo/config"#, mirror));
+    s
+}

src/main.rs

@@ -4,13 +4,34 @@ extern crate rust_util;
 mod build_util;
 mod docker_util;
 
+use std::fs;
 use std::env;
+use std::path::Path;
+use rust_util::util_file;
 pub use docker_util::DockerCmd;
 
+const DOCKER_REGISTRY: &str = "~/.dockerbuild/register/rust_1_47";
+const MIRROR_USTC: &str = "git://mirrors.ustc.edu.cn/crates.io-index";
+
 fn main() {
     information!("dockerbuild v0.1");
 
+    let docker_registry_path_buf = util_file::get_absolute_path(DOCKER_REGISTRY).expect("Cannot find $HOME !");
+    let docker_registry = docker_registry_path_buf.to_str().expect("Cannot find $HOME !!");
+
+    let p = Path::new(&docker_registry);
+    if !p.exists() {
+        if let Err(e) = fs::create_dir_all(&docker_registry) {
+            failure!("Create dir failed: {:?}, error: {}", p, e);
+            return;
+        }
+    }
+
     let args_iter = env::args().skip(1);
     let args = args_iter.map(|a| a.to_owned()).collect::<Vec<_>>();
-    DockerCmd::new("rust:1.47").exec(&args).unwrap();
+    let mut docker_cmd = DockerCmd::new("rust:1.47");
+    docker_cmd.add_volumn(docker_registry, "/usr/local/cargo/registry")
+              .mirror(MIRROR_USTC);
+    docker_cmd.exec(&args).unwrap();
 }
+