Merge pull request #243 from TimNN/backtrace-lives-again

re-add backtrace functionality

Author: alexcrichton

src/bin/playbot.rs

@@ -33,6 +33,7 @@ fn get_rust_versions(cache: &Cache) -> Vec<String> {
         let (status, output) = cache.exec(*channel,
                                           "rustc",
                                           vec![String::from("-V")],
+                                          vec![],
                                           String::new()).unwrap();
         assert!(status.success(), "couldn't get version (this currently needs to run as root)");
         let version = str::from_utf8(&output).unwrap();
@@ -84,6 +85,7 @@ impl Playbot {
         let (_status, output) = try!(self.cache.exec(channel,
                                                      "/usr/local/bin/evaluate.sh",
                                                      Vec::new(),
+                                                     Vec::new(),
                                                      String::from(full_code)));
 
         let output_merged = output.splitn(2, |b| *b == b'\xff')

src/bin/playpen.rs

@@ -78,6 +78,7 @@ struct EvaluateReq {
     optimize: Option<String>,
     separate_output: Option<bool>,
     code: String,
+    backtrace: Option<String>,
 }
 
 fn evaluate(req: &mut Request) -> IronResult<Response> {
@@ -90,6 +91,7 @@ fn evaluate(req: &mut Request) -> IronResult<Response> {
     let version = itry!(data.version.map(|v| v.parse()).unwrap_or(Ok(ReleaseChannel::Stable)));
     let opt = itry!(data.optimize.map(|opt| opt.parse()).unwrap_or(Ok(OptLevel::O2)));
     let separate_output = data.separate_output.unwrap_or(false);
+    let backtrace = itry!(data.backtrace.map(|b| b.parse()).unwrap_or(Ok(Backtrace::Auto)));
 
     let mut args = vec![String::from("-C"), format!("opt-level={}", opt.as_u8())];
     if opt == OptLevel::O0 {
@@ -102,10 +104,16 @@ fn evaluate(req: &mut Request) -> IronResult<Response> {
         args.push(String::from("--test"));
     }
 
+    let mut env = vec![];
+    if backtrace.is_requested(opt == OptLevel::O0) {
+        env.push(("RUST_BACKTRACE".into(), "1".into()));
+    }
+
     let cache = req.extensions.get::<AddCache>().unwrap();
     let (_status, output) = itry!(cache.exec(version,
                                              "/usr/local/bin/evaluate.sh",
                                              args,
+                                             env,
                                              data.code));
 
     let mut obj = json::Object::new();
@@ -141,6 +149,7 @@ struct CompileReq {
     optimize: Option<String>,
     emit: Option<String>,
     code: String,
+    backtrace: Option<String>,
 }
 
 fn compile(req: &mut Request) -> IronResult<Response> {
@@ -153,6 +162,7 @@ fn compile(req: &mut Request) -> IronResult<Response> {
     let version = itry!(data.version.map(|v| v.parse()).unwrap_or(Ok(ReleaseChannel::Stable)));
     let opt = itry!(data.optimize.map(|opt| opt.parse()).unwrap_or(Ok(OptLevel::O2)));
     let emit = itry!(data.emit.map(|emit| emit.parse()).unwrap_or(Ok(CompileOutput::Asm)));
+    let backtrace = itry!(data.backtrace.map(|b| b.parse()).unwrap_or(Ok(Backtrace::Auto)));
 
     let mut args = vec![
         String::from("-C"),
@@ -170,10 +180,16 @@ fn compile(req: &mut Request) -> IronResult<Response> {
         args.push(String::from("--color=always"));
     }
 
+    let mut env = vec![];
+    if backtrace.is_requested(opt == OptLevel::O0) {
+        env.push(("RUST_BACKTRACE".into(), "1".into()));
+    }
+
     let cache = req.extensions.get::<AddCache>().unwrap();
     let (_status, output) = itry!(cache.exec(version,
                                              "/usr/local/bin/compile.sh",
                                              args,
+                                             env,
                                              data.code));
     let mut split = output.splitn(2, |b| *b == b'\xff');
     let rustc = String::from_utf8(split.next().unwrap().into()).unwrap();
@@ -198,6 +214,7 @@ fn compile(req: &mut Request) -> IronResult<Response> {
 struct FormatReq {
     version: Option<String>,
     code: String,
+    backtrace: Option<String>,
 }
 
 fn format(req: &mut Request) -> IronResult<Response> {
@@ -206,11 +223,18 @@ fn format(req: &mut Request) -> IronResult<Response> {
 
     let data: FormatReq = itry!(json::decode(&body));
     let version = itry!(data.version.map(|v| v.parse()).unwrap_or(Ok(ReleaseChannel::Stable)));
+    let backtrace = itry!(data.backtrace.map(|b| b.parse()).unwrap_or(Ok(Backtrace::Auto)));
+
+    let mut env = vec![];
+    if backtrace == Backtrace::Always {
+        env.push(("RUST_BACKTRACE".into(), "1".into()));
+    }
 
     let cache = req.extensions.get::<AddCache>().unwrap();
     let (status, output) = itry!(cache.exec(version,
                                             "rustfmt",
                                             Vec::new(),
+                                            env,
                                             data.code));
     let output = String::from_utf8(output).unwrap();
     let mut response_obj = json::Object::new();

src/docker.rs

@@ -15,6 +15,7 @@ pub struct Container {
 impl Container {
     pub fn new(cmd: &str,
                args: &[String],
+               env: &[(String, String)],
                name: &str) -> io::Result<Container> {
         let out = try!(run(Command::new("docker")
                                    .arg("create")
@@ -24,6 +25,7 @@ impl Container {
                                    .arg("--pids-limit=20")
                                    .arg("--security-opt=no-new-privileges")
                                    .arg("--interactive")
+                                   .args(&env.iter().map(|&(ref k, ref v)| format!("-e{}={}", k, v)).collect::<Vec<_>>())
                                    .arg(name)
                                    .arg(cmd)
                                    .stderr(Stdio::inherit())

src/lib.rs

@@ -69,6 +69,7 @@ struct CacheKey {
     channel: ReleaseChannel,
     cmd: String,
     args: Vec<String>,
+    env: Vec<(String, String)>,
     input: String,
 }
 
@@ -84,13 +85,15 @@ impl Cache {
                 channel: ReleaseChannel,
                 cmd: &str,
                 args: Vec<String>,
+                env: Vec<(String, String)>,
                 input: String)
                 -> io::Result<(ExitStatus, Vec<u8>)> {
         // Build key to look up
         let key = CacheKey {
             channel: channel,
             cmd: cmd.to_string(),
             args: args,
+            env: env,
             input: input,
         };
         let mut cache = self.cache.lock().unwrap();
@@ -106,7 +109,7 @@ impl Cache {
         };
         let container = format!("rust-playpen-{}", chan);
 
-        let container = try!(Container::new(cmd, &key.args, &container));
+        let container = try!(Container::new(cmd, &key.args, &key.env, &container));
 
         let tuple = try!(container.run(key.input.as_bytes(), Duration::new(5, 0)));
         let (status, mut output, timeout) = tuple;
@@ -145,6 +148,36 @@ impl FromStr for AsmFlavor {
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum Backtrace {
+    Never,
+    Always,
+    Auto,
+}
+
+impl Backtrace {
+    pub fn is_requested(&self, debug: bool) -> bool {
+        match *self {
+            Backtrace::Never => false,
+            Backtrace::Always => true,
+            Backtrace::Auto => debug,
+        }
+    }
+}
+
+impl FromStr for Backtrace {
+    type Err = StringError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "0" => Ok(Backtrace::Never),
+            "1" => Ok(Backtrace::Always),
+            "2" => Ok(Backtrace::Auto),
+            _ => Err(StringError(format!("unknown backtrace setting {}", s))),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub enum OptLevel {
     O0,
@@ -249,6 +282,7 @@ mod tests {
         let (status, out) = cache.exec(ReleaseChannel::Stable,
                                        "/usr/local/bin/evaluate.sh",
                                        Vec::new(),
+                                       Vec::new(),
                                        input.to_string()).unwrap();
         assert!(status.success());
         assert_eq!(out, &[0xff, b'H', b'e', b'l', b'l', b'o', b'\n']);
@@ -267,6 +301,7 @@ mod tests {
         let (status, out) = cache.exec(ReleaseChannel::Stable,
                                        "/usr/local/bin/evaluate.sh",
                                        Vec::new(),
+                                       Vec::new(),
                                        input.to_string()).unwrap();
         assert!(!status.success());
         assert!(String::from_utf8_lossy(&out).contains("timeout triggered"));
@@ -281,6 +316,7 @@ mod tests {
         let (status, out) = cache.exec(ReleaseChannel::Stable,
                                        "/usr/local/bin/compile.sh",
                                        vec![String::from("--emit=llvm-ir")],
+                                       vec![],
                                        input.to_string()).unwrap();
 
         assert!(status.success());
@@ -300,6 +336,7 @@ mod tests {
         let (status, out) = cache.exec(ReleaseChannel::Stable,
                                        "rustfmt",
                                        Vec::new(),
+                                       Vec::new(),
                                        input.to_string()).unwrap();
         assert!(status.success());
         assert!(String::from_utf8(out).unwrap().contains(r#""Hello""#))