Sped up the compilation/execution of snippets by using previously

started and idle docker containers, rather than starting a new one for
each request.
By sleeping for a long time in entrypoint.sh, containers stay idle.
Cargo is called through cargo.sh, which cares of exporting env vars
and killing the container once it's done. Thus, there's no need to drop
a container that has been used.
However idle containers need to me manually terminated:
DockerContainers Drop impl takes care of that.

Author: ffissore

compiler/base/Dockerfile

@@ -41,6 +41,7 @@ RUN cd / && \
 WORKDIR /playground
 
 ADD Cargo.toml /playground/Cargo.toml
+ADD cargo.sh /playground/cargo.sh
 ADD crate-information.json /playground/crate-information.json
 RUN cargo fetch
 

compiler/base/cargo.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -eu
+
+POSITIONAL=()
+
+while [[ $# -gt 0 ]]; do
+        case $1 in
+                --env)
+                        export $2
+                        shift 2
+                        ;;
+                *)
+                        POSITIONAL+=("$1")
+                        shift
+                        ;;
+        esac
+done
+
+eval set -- "${POSITIONAL[@]}"
+
+timeout=${PLAYGROUND_TIMEOUT:-10}
+
+modify-cargo-toml
+
+timeout --signal=KILL ${timeout} cargo "$@" || pkill sleep
+
+pkill sleep

compiler/base/entrypoint.sh

@@ -1,8 +1,3 @@
 #!/bin/bash
 
-set -eu
-
-timeout=${PLAYGROUND_TIMEOUT:-10}
-
-modify-cargo-toml
-timeout --signal=KILL ${timeout} "$@"
+sleep 365d

ui/src/main.rs

@@ -49,11 +49,12 @@ use serde::Serialize;
 use serde::de::DeserializeOwned;
 use snafu::{ResultExt, Snafu};
 
-use sandbox::Sandbox;
+use sandbox::{Channel, DockerContainers, Sandbox};
 
 const DEFAULT_ADDRESS: &str = "127.0.0.1";
 const DEFAULT_PORT: u16 = 5000;
 const DEFAULT_LOG_FILE: &str = "access-log.csv";
+const DEFAULT_DOCKER_CONTAINER_POOL_SIZE: usize = 10;
 
 mod sandbox;
 mod asm_cleanup;
@@ -78,6 +79,9 @@ fn main() {
     let port = env::var("PLAYGROUND_UI_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(DEFAULT_PORT);
     let logfile = env::var("PLAYGROUND_LOG_FILE").unwrap_or_else(|_| DEFAULT_LOG_FILE.to_string());
     let cors_enabled = env::var_os("PLAYGROUND_CORS_ENABLED").is_some();
+    let docker_containers_pool_size = env::var("DOCKER_CONTAINER_POOL_SIZE").ok().and_then(|v| v.parse().ok()).unwrap_or(DEFAULT_DOCKER_CONTAINER_POOL_SIZE);
+
+    let containers = Arc::new(DockerContainers::new(docker_containers_pool_size));
 
     let files = Staticfile::new(&root).expect("Unable to open root directory");
     let mut files = Chain::new(files);
@@ -94,8 +98,10 @@ fn main() {
 
     let mut mount = Mount::new();
     mount.mount("/", files);
-    mount.mount("/compile", compile);
-    mount.mount("/execute", execute);
+    let containers_clone = containers.clone();
+    mount.mount("/compile", move |req: &mut Request| compile(req, &containers_clone));
+    let containers_clone = containers.clone();
+    mount.mount("/execute", move |req: &mut Request| handle(req, &containers_clone));
     mount.mount("/format", format);
     mount.mount("/clippy", clippy);
     mount.mount("/miri", miri);
@@ -107,7 +113,8 @@ fn main() {
     mount.mount("/meta/version/clippy", meta_version_clippy);
     mount.mount("/meta/version/miri", meta_version_miri);
     mount.mount("/meta/gist", gist_router);
-    mount.mount("/evaluate.json", evaluate);
+    let containers_clone = containers.clone();
+    mount.mount("/evaluate.json", move |req: &mut Request| evaluate(req, &containers_clone));
 
     let mut chain = Chain::new(mount);
     let file_logger = FileLogger::new(logfile).expect("Unable to create file logger");
@@ -158,21 +165,23 @@ impl iron::typemap::Key for GhToken {
     type Value = Self;
 }
 
-fn compile(req: &mut Request) -> IronResult<Response> {
+fn compile(req: &mut Request, containers: &DockerContainers) -> IronResult<Response> {
     with_sandbox(req, |sandbox, req: CompileRequest| {
-        let req = try!(req.try_into());
+        let req: sandbox::CompileRequest = try!(req.try_into());
+        let container = containers.pop(req.channel).unwrap();
         sandbox
-            .compile(&req)
+            .compile(&req, &container)
             .map(CompileResponse::from)
             .eager_context(Compilation)
     })
 }
 
-fn execute(req: &mut Request) -> IronResult<Response> {
+fn handle(req: &mut Request, containers: &DockerContainers) -> IronResult<Response> {
     with_sandbox(req, |sandbox, req: ExecuteRequest| {
-        let req = try!(req.try_into());
+        let req: sandbox::ExecuteRequest = try!(req.try_into());
+        let container = containers.pop(req.channel).unwrap();
         sandbox
-            .execute(&req)
+            .execute(&req, &container)
             .map(ExecuteResponse::from)
             .eager_context(Execution)
     })
@@ -285,11 +294,12 @@ fn meta_gist_get(req: &mut Request) -> IronResult<Response> {
 
 // This is a backwards compatibilty shim. The Rust homepage and the
 // documentation use this to run code in place.
-fn evaluate(req: &mut Request) -> IronResult<Response> {
+fn evaluate(req: &mut Request, containers: &DockerContainers) -> IronResult<Response> {
     with_sandbox(req, |sandbox, req: EvaluateRequest| {
         let req = req.try_into()?;
+        let container = containers.pop(Channel::Stable).unwrap();
         sandbox
-            .execute(&req)
+            .execute(&req, &container)
             .map(EvaluateResponse::from)
             .eager_context(Evaluation)
     })