Expose direct access to toolchain packagers

Author: aidanhs

src/cmdline.rs

@@ -36,14 +36,16 @@ arg_enum!{
 pub enum Command {
     /// Show cache statistics and exit.
     ShowStats(StatsFormat),
-    /// Zero cache statistics and exit.
-    ZeroStats,
     /// Run background server.
     InternalStartServer,
     /// Start background server as a subprocess.
     StartServer,
     /// Stop background server.
     StopServer,
+    /// Zero cache statistics and exit.
+    ZeroStats,
+    /// Package a toolchain for distributed compilation (executable, out)
+    PackageToolchain(PathBuf, PathBuf),
     /// Run a compiler command.
     Compile {
         /// The binary to execute.
@@ -71,11 +73,13 @@ pub fn get_app<'a, 'b>() -> App<'a, 'b> {
                 "    Azure:     ", cfg!(feature = "azure"), "\n")
                 )
         .args_from_usage(
-            "-s --show-stats 'show cache statistics'
-             -z, --zero-stats 'zero statistics counters'
-             --start-server  'start background server'
-             --stop-server   'stop background server'"
+            "-s --show-stats  'show cache statistics'
+             --start-server   'start background server'
+             --stop-server    'stop background server'
+             -z, --zero-stats 'zero statistics counters'"
                 )
+        .arg(Arg::from_usage("--package-toolchain <executable> <out> 'package toolchain for distributed compilation'")
+             .required(false))
         .arg(Arg::from_usage("--stats-format  'set output format of statistics'")
              .possible_values(&StatsFormat::variants())
              .default_value("text"))
@@ -131,6 +135,7 @@ pub fn parse() -> Result<Command> {
     let start_server = matches.is_present("start-server");
     let stop_server = matches.is_present("stop-server");
     let zero_stats = matches.is_present("zero-stats");
+    let package_toolchain = matches.is_present("package-toolchain");
     let cmd = matches.values_of_os("cmd");
     // Ensure that we've only received one command to run.
     fn is_some<T>(x : &Option<T>) -> bool {
@@ -141,6 +146,8 @@ pub fn parse() -> Result<Command> {
         show_stats,
         start_server,
         stop_server,
+        zero_stats,
+        package_toolchain,
         is_some(&cmd),
             ].iter()
         .filter(|&&x| x).count() > 1 {
@@ -158,6 +165,11 @@ pub fn parse() -> Result<Command> {
         Ok(Command::StopServer)
     } else if zero_stats {
         Ok(Command::ZeroStats)
+    } else if package_toolchain {
+        let mut values = matches.values_of_os("package-toolchain").unwrap();
+        assert!(values.len() == 2);
+        let (executable, out) = (values.next().unwrap(), values.next().unwrap());
+        Ok(Command::PackageToolchain(executable.into(), out.into()))
     } else if let Some(mut args) = cmd {
         if let Some(exe) = args.next() {
             let cmdline = args.map(|s| s.to_owned()).collect::<Vec<_>>();

src/commands.rs

@@ -618,6 +618,36 @@ pub fn run_command(cmd: Command) -> Result<i32> {
             let stats = request_shutdown(server)?;
             stats.print();
         }
+        Command::ZeroStats => {
+            trace!("Command::ZeroStats");
+            let conn = connect_or_start_server(get_port())?;
+            let stats = request_zero_stats(conn).chain_err(|| {
+                "couldn't zero stats on server"
+            })?;
+            stats.print();
+        }
+        #[cfg(feature = "dist-client")]
+        Command::PackageToolchain(executable, out) => {
+            use compiler;
+            use futures_cpupool::CpuPool;
+
+            trace!("Command::PackageToolchain({})", executable.display());
+            let mut core = Core::new()?;
+            let jobserver = unsafe { Client::new() };
+            let creator = ProcessCommandCreator::new(&core.handle(), &jobserver);
+            let env: Vec<_> = env::vars_os().collect();
+            let pool = CpuPool::new(1);
+            let out_file = File::create(out)?;
+
+            let compiler = compiler::get_compiler_info(&creator, &executable, &env, &pool);
+            let packager = compiler.map(|c| c.get_toolchain_packager());
+            let res = packager.and_then(|p| p.write_pkg(out_file));
+            core.run(res)?
+        }
+        #[cfg(not(feature = "dist-client"))]
+        Command::PackageToolchain(_executable, _out) => {
+            bail!("Toolchain packaging not compiled in")
+        }
         Command::Compile { exe, cmdline, cwd, env_vars } => {
             trace!("Command::Compile {{ {:?}, {:?}, {:?} }}", exe, cmdline, cwd);
             let jobserver = unsafe { Client::new() };
@@ -637,14 +667,6 @@ pub fn run_command(cmd: Command) -> Result<i32> {
                 "failed to execute compile"
             })
         }
-        Command::ZeroStats => {
-            trace!("Command::ZeroStats");
-            let conn = connect_or_start_server(get_port())?;
-            let stats = request_zero_stats(conn).chain_err(|| {
-                "couldn't zero stats on server"
-            })?;
-            stats.print();
-        }
     }
 
     Ok(0)

src/compiler/c.rs

@@ -187,6 +187,10 @@ impl <I> CCompiler<I>
 
 impl<T: CommandCreatorSync, I: CCompilerImpl> Compiler<T> for CCompiler<I> {
     fn kind(&self) -> CompilerKind { CompilerKind::C(self.compiler.kind()) }
+    #[cfg(feature = "dist-client")]
+    fn get_toolchain_packager(&self) -> Box<pkg::ToolchainPackager> {
+        Box::new(CToolchainPackager { executable: self.executable.clone() })
+    }
     fn parse_arguments(&self,
                        arguments: &[OsString],
                        cwd: &Path) -> CompilerArguments<Box<CompilerHasher<T> + 'static>> {
@@ -362,7 +366,7 @@ impl pkg::ToolchainPackager for CToolchainPackager {
         use std::env;
         use std::os::unix::ffi::OsStrExt;
 
-        info!("Packaging C compiler");
+        info!("Packaging C compiler for executable {}", self.executable.display());
         // TODO: write our own, since this is GPL
         let curdir = env::current_dir().unwrap();
         env::set_current_dir("/tmp").unwrap();

src/compiler/compiler.rs

@@ -93,6 +93,9 @@ pub trait Compiler<T>: Send + 'static
 {
     /// Return the kind of compiler.
     fn kind(&self) -> CompilerKind;
+    /// Retrieve a packager
+    #[cfg(feature = "dist-client")]
+    fn get_toolchain_packager(&self) -> Box<pkg::ToolchainPackager>;
     /// Determine whether `arguments` are supported by this compiler.
     fn parse_arguments(&self,
                        arguments: &[OsString],

src/compiler/rust.rs

@@ -388,6 +388,10 @@ impl<T> Compiler<T> for Rust
     where T: CommandCreatorSync,
 {
     fn kind(&self) -> CompilerKind { CompilerKind::Rust }
+    #[cfg(feature = "dist-client")]
+    fn get_toolchain_packager(&self) -> Box<pkg::ToolchainPackager> {
+        Box::new(RustToolchainPackager { sysroot: self.sysroot.clone() })
+    }
     /// Parse `arguments` as rustc command-line arguments, determine if
     /// we can cache the result of compilation. This is only intended to
     /// cover a subset of rustc invocations, primarily focused on those