Route evaluate requests through the orchestrator

Author: shepmaster

ui/src/main.rs

@@ -209,6 +209,11 @@ enum Error {
     #[snafu(display("Unable to serialize response: {}", source))]
     Serialization { source: serde_json::Error },
 
+    #[snafu(context(false))]
+    EvaluateRequest {
+        source: server_axum::api_orchestrator_integration_impls::ParseEvaluateRequestError,
+    },
+
     #[snafu(context(false))]
     CompileRequest {
         source: server_axum::api_orchestrator_integration_impls::ParseCompileRequestError,
@@ -254,6 +259,11 @@ enum Error {
         source: orchestrator::coordinator::Error,
     },
 
+    #[snafu(display("Unable to convert the evaluate request"))]
+    Evaluate {
+        source: orchestrator::coordinator::ExecuteError,
+    },
+
     #[snafu(display("Unable to convert the compile request"))]
     Compile {
         source: orchestrator::coordinator::CompileError,

ui/src/server_axum.rs

@@ -8,12 +8,12 @@ use crate::{
     sandbox::{self, Channel, Sandbox, DOCKER_PROCESS_TIMEOUT_SOFT},
     CachingSnafu, ClippyRequest, ClippyResponse, CompilationSnafu, CompileRequest, CompileResponse,
     CompileSnafu, Config, CreateCoordinatorSnafu, Error, ErrorJson, EvaluateRequest,
-    EvaluateResponse, EvaluationSnafu, ExecuteRequest, ExecuteResponse, ExecuteSnafu,
-    ExecutionSnafu, ExpansionSnafu, FormatRequest, FormatResponse, FormattingSnafu, GhToken,
-    GistCreationSnafu, GistLoadingSnafu, InterpretingSnafu, LintingSnafu, MacroExpansionRequest,
-    MacroExpansionResponse, MetaCratesResponse, MetaGistCreateRequest, MetaGistResponse,
-    MetaVersionResponse, MetricsToken, MiriRequest, MiriResponse, Result, SandboxCreationSnafu,
-    ShutdownCoordinatorSnafu, TimeoutSnafu,
+    EvaluateResponse, EvaluateSnafu, EvaluationSnafu, ExecuteRequest, ExecuteResponse,
+    ExecuteSnafu, ExecutionSnafu, ExpansionSnafu, FormatRequest, FormatResponse, FormattingSnafu,
+    GhToken, GistCreationSnafu, GistLoadingSnafu, InterpretingSnafu, LintingSnafu,
+    MacroExpansionRequest, MacroExpansionResponse, MetaCratesResponse, MetaGistCreateRequest,
+    MetaGistResponse, MetaVersionResponse, MetricsToken, MiriRequest, MiriResponse, Result,
+    SandboxCreationSnafu, ShutdownCoordinatorSnafu, TimeoutSnafu,
 };
 use async_trait::async_trait;
 use axum::{
@@ -151,15 +151,24 @@ async fn rewrite_help_as_index<B>(
 
 // This is a backwards compatibilty shim. The Rust documentation uses
 // this to run code in place.
-async fn evaluate(Json(req): Json<EvaluateRequest>) -> Result<Json<EvaluateResponse>> {
-    with_sandbox_force_endpoint(
-        req,
-        Endpoint::Evaluate,
-        |sb, req| async move { sb.execute(req).await }.boxed(),
-        EvaluationSnafu,
-    )
-    .await
-    .map(Json)
+async fn evaluate(
+    Extension(use_orchestrator): Extension<OrchestratorEnabled>,
+    Json(req): Json<EvaluateRequest>,
+) -> Result<Json<EvaluateResponse>> {
+    if use_orchestrator.0 {
+        with_coordinator(req, |c, req| c.execute(req).context(EvaluateSnafu).boxed())
+            .await
+            .map(Json)
+    } else {
+        with_sandbox_force_endpoint(
+            req,
+            Endpoint::Evaluate,
+            |sb, req| async move { sb.execute(req).await }.boxed(),
+            EvaluationSnafu,
+        )
+        .await
+        .map(Json)
+    }
 }
 
 async fn compile(
@@ -283,6 +292,10 @@ pub(crate) trait HasEndpoint {
     const ENDPOINT: Endpoint;
 }
 
+impl HasEndpoint for EvaluateRequest {
+    const ENDPOINT: Endpoint = Endpoint::Evaluate;
+}
+
 impl HasEndpoint for CompileRequest {
     const ENDPOINT: Endpoint = Endpoint::Compile;
 }
@@ -800,6 +813,83 @@ pub(crate) mod api_orchestrator_integration_impls {
     use snafu::prelude::*;
     use std::convert::TryFrom;
 
+    impl TryFrom<crate::EvaluateRequest> for ExecuteRequest {
+        type Error = ParseEvaluateRequestError;
+
+        fn try_from(other: crate::EvaluateRequest) -> Result<Self, Self::Error> {
+            let crate::EvaluateRequest {
+                version,
+                optimize,
+                code,
+                edition,
+                tests,
+            } = other;
+
+            let mode = if optimize != "0" {
+                Mode::Release
+            } else {
+                Mode::Debug
+            };
+
+            let edition = if edition.trim().is_empty() {
+                Edition::Rust2015
+            } else {
+                parse_edition(&edition)?
+            };
+
+            Ok(ExecuteRequest {
+                channel: parse_channel(&version)?,
+                mode,
+                edition,
+                crate_type: CrateType::Binary,
+                tests,
+                backtrace: false,
+                code,
+            })
+        }
+    }
+
+    #[derive(Debug, Snafu)]
+    pub(crate) enum ParseEvaluateRequestError {
+        #[snafu(context(false))]
+        Channel { source: ParseChannelError },
+
+        #[snafu(context(false))]
+        Edition { source: ParseEditionError },
+    }
+
+    impl From<WithOutput<ExecuteResponse>> for crate::EvaluateResponse {
+        fn from(other: WithOutput<ExecuteResponse>) -> Self {
+            let WithOutput {
+                response,
+                stdout,
+                stderr,
+            } = other;
+
+            // The old playground didn't use Cargo, so it never had the
+            // Cargo output ("Compiling playground...") which is printed
+            // to stderr. Since this endpoint is used to inline results on
+            // the page, don't include the stderr unless an error
+            // occurred.
+            if response.success {
+                crate::EvaluateResponse {
+                    result: stdout,
+                    error: None,
+                }
+            } else {
+                // When an error occurs, *some* consumers check for an
+                // `error` key, others assume that the error is crammed in
+                // the `result` field and then they string search for
+                // `error:` or `warning:`. Ew. We can put it in both.
+                let result = stderr + &stdout;
+                crate::EvaluateResponse {
+                    result: result.clone(),
+                    error: Some(result),
+                }
+            }
+        }
+    }
+
     impl TryFrom<crate::CompileRequest> for CompileRequest {
         type Error = ParseCompileRequestError;