docker: switch build env to rustops/crates-build-env

Author: pietroalbini

ci/run/minicrater-linux.sh

@@ -2,5 +2,5 @@
 set -euo pipefail
 IFS=$'\n\t'
 
-cargo run -- prepare-local --docker-env=mini
+cargo run -- create-lists
 MINICRATER_SHOW_OUTPUT=1 cargo test -- --ignored --nocapture --test-threads 1

docs/cli-usage.md

@@ -10,7 +10,7 @@ of its output is into the `./work` directory, where it maintains its
 own rustup installation, crate mirrors, etc.
 
 ```
-cargo run -- prepare-local --docker-env mini
+cargo run -- prepare-local
 cargo run -- define-ex --crate-select=demo --cap-lints=forbid stable beta
 cargo run -- run-graph --threads NUM_CPUS
 cargo run -- gen-report work/ex/default/

src/agent/mod.rs

@@ -47,15 +47,15 @@ fn run_heartbeat(url: &str, token: &str) {
     });
 }
 
-pub fn run(url: &str, token: &str, threads_count: usize) -> Fallible<()> {
+pub fn run(url: &str, token: &str, threads_count: usize, docker_env: &str) -> Fallible<()> {
     let agent = Agent::new(url, token)?;
     let db = results::ResultsUploader::new(&agent.api);
 
     run_heartbeat(url, token);
 
     loop {
         let ex = agent.experiment()?;
-        ::runner::run_ex(&ex, &db, threads_count, &agent.config)?;
+        ::runner::run_ex(&ex, &db, threads_count, &agent.config, docker_env)?;
         agent.api.complete_experiment()?;
     }
 }

src/cli.rs

@@ -14,7 +14,6 @@ use crater::agent;
 use crater::config::Config;
 use crater::crates::Crate;
 use crater::db::Database;
-use crater::docker;
 use crater::experiments::{Assignee, CapLints, CrateSelect, Experiment, Mode, Status};
 use crater::report;
 use crater::results::{DatabaseDB, DeleteResults};
@@ -27,6 +26,8 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use structopt::clap::AppSettings;
 
+static DEFAULT_DOCKER_ENV: &str = "rustops/crates-build-env";
+
 // An experiment name
 #[derive(Debug, Clone)]
 pub struct Ex(String);
@@ -75,10 +76,7 @@ pub enum Crater {
         name = "prepare-local",
         about = "acquire toolchains, build containers, build crate lists"
     )]
-    PrepareLocal {
-        #[structopt(name = "docker env", long = "docker-env", default_value = "full")]
-        env: DockerEnv,
-    },
+    PrepareLocal,
 
     #[structopt(name = "create-lists", about = "create all the lists of crates")]
     CreateLists {
@@ -189,6 +187,8 @@ pub enum Crater {
         ex: Ex,
         #[structopt(name = "threads", short = "t", long = "threads", default_value = "1")]
         threads: usize,
+        #[structopt(name = "docker-env", long = "docker-env")]
+        docker_env: Option<String>,
     },
 
     #[structopt(name = "gen-report", about = "generate the experiment report")]
@@ -227,6 +227,8 @@ pub enum Crater {
         token: String,
         #[structopt(name = "threads", short = "t", long = "threads", default_value = "1")]
         threads: usize,
+        #[structopt(name = "docker-env", long = "docker-env")]
+        docker_env: Option<String>,
     },
 
     #[structopt(
@@ -275,12 +277,9 @@ impl Crater {
                     action.apply(&db, &config)?;
                 }
             }
-            Crater::PrepareLocal { ref env } => {
+            Crater::PrepareLocal => {
                 let config = Config::load()?;
                 let db = Database::open()?;
-
-                let docker_env = &env.0;
-                docker::build_container(docker_env)?;
                 actions::UpdateLists::default().apply(&db, &config)?;
             }
             Crater::DefineEx {
@@ -367,7 +366,15 @@ impl Crater {
                     bail!("missing experiment {}", ex.0);
                 }
             }
-            Crater::RunGraph { ref ex, threads } => {
+            Crater::RunGraph {
+                ref ex,
+                threads,
+                ref docker_env,
+            } => {
+                let docker_env = docker_env
+                    .as_ref()
+                    .map(|e| e.as_str())
+                    .unwrap_or(DEFAULT_DOCKER_ENV);
                 let config = Config::load()?;
                 let db = Database::open()?;
 
@@ -387,7 +394,7 @@ impl Crater {
                     }
 
                     let result_db = DatabaseDB::new(&db);
-                    runner::run_ex(&experiment, &result_db, threads, &config)?;
+                    runner::run_ex(&experiment, &result_db, threads, &config, docker_env)?;
                     experiment.set_status(&db, Status::NeedsReport)?;
                 } else {
                     bail!("missing experiment {}", ex.0);
@@ -481,8 +488,13 @@ impl Crater {
                 ref url,
                 ref token,
                 threads,
+                ref docker_env,
             } => {
-                agent::run(url, token, threads)?;
+                let docker_env = docker_env
+                    .as_ref()
+                    .map(|e| e.as_str())
+                    .unwrap_or(DEFAULT_DOCKER_ENV);
+                agent::run(url, token, threads, docker_env)?;
             }
             Crater::DumpTasksGraph { ref dest, ref ex } => {
                 let config = Config::load()?;

src/docker.rs

@@ -6,19 +6,6 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use utils::size::Size;
 
-pub(crate) static IMAGE_NAME: &'static str = "crater";
-
-/// Builds the docker container image, 'crater', what will be used
-/// to isolate builds from each other. This expects the Dockerfile
-/// to exist in the `docker` directory, at runtime.
-pub fn build_container(docker_env: &str) -> Fallible<()> {
-    let dockerfile = format!("docker/Dockerfile.{}", docker_env);
-    RunCommand::new("docker")
-        .args(&["build", "-f", &dockerfile, "-t", IMAGE_NAME, "docker"])
-        .enable_timeout(false)
-        .run()
-}
-
 pub(crate) fn is_running() -> bool {
     info!("checking if the docker daemon is running");
     RunCommand::new("docker")
@@ -28,6 +15,41 @@ pub(crate) fn is_running() -> bool {
         .is_ok()
 }
 
+pub(crate) struct DockerEnv {
+    image: String,
+    local: bool,
+}
+
+impl DockerEnv {
+    pub(crate) fn new(image: &str) -> Self {
+        DockerEnv {
+            image: image.to_string(),
+            local: !image.contains('/'),
+        }
+    }
+
+    pub(crate) fn ensure_exists_locally(&self) -> Fallible<()> {
+        if !self.local {
+            self.pull()?;
+        } else {
+            info!("docker environment is local, skipping pull");
+        }
+
+        info!("checking the image {} is available locally", self.image);
+        RunCommand::new("docker")
+            .args(&["image", "inspect", &self.image])
+            .hide_output(true)
+            .run()?;
+
+        Ok(())
+    }
+
+    fn pull(&self) -> Fallible<()> {
+        info!("pulling image {} from Docker Hub", self.image);
+        RunCommand::new("docker").args(&["pull", &self.image]).run()
+    }
+}
+
 #[derive(Copy, Clone)]
 pub(crate) enum MountPerms {
     ReadWrite,
@@ -55,21 +77,25 @@ impl MountConfig {
     }
 }
 
-pub(crate) struct ContainerBuilder {
-    image: String,
+pub(crate) struct ContainerBuilder<'a> {
+    image: &'a DockerEnv,
     mounts: Vec<MountConfig>,
     env: Vec<(String, String)>,
     memory_limit: Option<Size>,
+    workdir: Option<String>,
+    cmd: Vec<String>,
     enable_networking: bool,
 }
 
-impl ContainerBuilder {
-    pub(crate) fn new<S: Into<String>>(image: S) -> Self {
+impl<'a> ContainerBuilder<'a> {
+    pub(crate) fn new(image: &'a DockerEnv) -> Self {
         ContainerBuilder {
-            image: image.into(),
+            image,
             mounts: Vec::new(),
             env: Vec::new(),
+            workdir: None,
             memory_limit: None,
+            cmd: Vec::new(),
             enable_networking: true,
         }
     }
@@ -93,11 +119,21 @@ impl ContainerBuilder {
         self
     }
 
+    pub(crate) fn workdir<S: Into<String>>(mut self, workdir: S) -> Self {
+        self.workdir = Some(workdir.into());
+        self
+    }
+
     pub(crate) fn memory_limit(mut self, limit: Option<Size>) -> Self {
         self.memory_limit = limit;
         self
     }
 
+    pub(crate) fn cmd(mut self, cmd: Vec<String>) -> Self {
+        self.cmd = cmd;
+        self
+    }
+
     pub(crate) fn enable_networking(mut self, enable: bool) -> Self {
         self.enable_networking = enable;
         self
@@ -117,6 +153,11 @@ impl ContainerBuilder {
             args.push(format! {"{}={}", var, value})
         }
 
+        if let Some(workdir) = self.workdir {
+            args.push("-w".into());
+            args.push(workdir);
+        }
+
         if let Some(limit) = self.memory_limit {
             args.push("-m".into());
             args.push(limit.to_string());
@@ -127,7 +168,11 @@ impl ContainerBuilder {
             args.push("none".into());
         }
 
-        args.push(self.image);
+        args.push(self.image.image.clone());
+
+        for arg in self.cmd {
+            args.push(arg);
+        }
 
         let (out, _) = RunCommand::new("docker").args(&*args).run_capture()?;
         Ok(Container { id: out[0].clone() })

src/lib.rs

@@ -72,7 +72,7 @@ pub mod config;
 pub mod crates;
 pub mod db;
 pub mod dirs;
-pub mod docker;
+mod docker;
 pub mod experiments;
 mod native;
 mod prelude;

src/run.rs

@@ -1,5 +1,6 @@
 use dirs::{CARGO_HOME, RUSTUP_HOME};
-use docker::{ContainerBuilder, MountPerms, IMAGE_NAME};
+use docker::DockerEnv;
+use docker::{ContainerBuilder, MountPerms};
 use failure::Error;
 use futures::{future, Future, Stream};
 use native;
@@ -123,8 +124,8 @@ impl RunCommand {
         self
     }
 
-    pub(crate) fn sandboxed(self) -> SandboxedCommand {
-        SandboxedCommand::new(self)
+    pub(crate) fn sandboxed(self, docker_env: &DockerEnv) -> SandboxedCommand {
+        SandboxedCommand::new(self, docker_env)
     }
 
     pub(crate) fn run(self) -> Fallible<()> {
@@ -187,14 +188,14 @@ impl RunCommand {
     }
 }
 
-pub(crate) struct SandboxedCommand {
+pub(crate) struct SandboxedCommand<'a> {
     command: RunCommand,
-    container: ContainerBuilder,
+    container: ContainerBuilder<'a>,
 }
 
-impl SandboxedCommand {
-    fn new(command: RunCommand) -> Self {
-        let container = ContainerBuilder::new(IMAGE_NAME)
+impl<'a> SandboxedCommand<'a> {
+    fn new(command: RunCommand, docker_env: &'a DockerEnv) -> Self {
+        let container = ContainerBuilder::new(docker_env)
             .env("USER_ID", native::current_user().to_string())
             .enable_networking(false);
 
@@ -218,16 +219,21 @@ impl SandboxedCommand {
 
     pub(crate) fn run(mut self) -> Fallible<()> {
         // Build the full CLI
-        let mut cmd = match self.command.binary {
-            Binary::Global(path) => path,
-            Binary::InstalledByCrater(path) => path,
-        }
-        .to_string_lossy()
-        .as_ref()
-        .to_string();
+        let mut cmd = Vec::new();
+        cmd.push(
+            match self.command.binary {
+                Binary::Global(path) => path,
+                Binary::InstalledByCrater(path) => {
+                    PathBuf::from("/opt/crater/cargo-home/bin").join(path)
+                }
+            }
+            .to_string_lossy()
+            .as_ref()
+            .to_string(),
+        );
+
         for arg in self.command.args {
-            cmd.push(' ');
-            cmd.push_str(arg.to_string_lossy().as_ref());
+            cmd.push(arg.to_string_lossy().to_string());
         }
 
         let source_dir = match self.command.cd {
@@ -237,10 +243,11 @@ impl SandboxedCommand {
 
         self.container = self
             .container
-            .mount(source_dir, "/source", MountPerms::ReadOnly)
-            .env("SOURCE_DIR", "/source")
-            .env("USER_ID", native::current_user().to_string())
-            .env("CMD", cmd);
+            .mount(source_dir, "/opt/crater/workdir", MountPerms::ReadOnly)
+            .env("SOURCE_DIR", "/opt/crater/workdir")
+            .env("MAP_USER_ID", native::current_user().to_string())
+            .workdir("/opt/crater/workdir")
+            .cmd(cmd);
 
         for (key, value) in self.command.env {
             self.container = self.container.env(
@@ -252,10 +259,14 @@ impl SandboxedCommand {
         if self.command.local_rustup {
             self.container = self
                 .container
-                .mount(&*CARGO_HOME, "/cargo-home", MountPerms::ReadOnly)
-                .mount(&*RUSTUP_HOME, "/rustup-home", MountPerms::ReadOnly)
-                .env("CARGO_HOME", "/cargo-home")
-                .env("RUSTUP_HOME", "/rustup-home");
+                .mount(&*CARGO_HOME, "/opt/crater/cargo-home", MountPerms::ReadOnly)
+                .mount(
+                    &*RUSTUP_HOME,
+                    "/opt/crater/rustup-home",
+                    MountPerms::ReadOnly,
+                )
+                .env("CARGO_HOME", "/opt/crater/cargo-home")
+                .env("RUSTUP_HOME", "/opt/crater/rustup-home");
         }
 
         self.container.run(self.command.quiet)