Optionally use the orchestrator for the "compile" commands in the UI

Author: shepmaster

ui/Cargo.lock

@@ -17,6 +17,7 @@ futures = "0.3.21"
 lazy_static = "1.0.0"
 octocrab = "0.25"
 openssl-probe = "0.1.2"
+orchestrator = { path = "../compiler/base/orchestrator" }
 prometheus = "0.13.0"
 regex = "1.0.0"
 serde = { version = "1.0", features = ["rc"] }

ui/Cargo.toml

@@ -37,6 +37,7 @@ struct Config {
     cors_enabled: bool,
     gh_token: Option<String>,
     metrics_token: Option<String>,
+    orchestrator_enabled: bool,
     port: u16,
     root: PathBuf,
 }
@@ -90,11 +91,14 @@ impl Config {
 
         let cors_enabled = env::var_os("PLAYGROUND_CORS_ENABLED").is_some();
 
+        let orchestrator_enabled = env::var_os("PLAYGROUND_ORCHESTRATOR_ENABLED").is_some();
+
         Self {
             address,
             cors_enabled,
             gh_token,
             metrics_token,
+            orchestrator_enabled,
             port,
             root,
         }
@@ -112,6 +116,10 @@ impl Config {
         self.cors_enabled
     }
 
+    fn use_orchestrator(&self) -> bool {
+        self.orchestrator_enabled
+    }
+
     fn metrics_token(&self) -> Option<MetricsToken> {
         self.metrics_token.as_deref().map(MetricsToken::new)
     }
@@ -203,6 +211,24 @@ pub enum Error {
     CachePoisoned,
     #[snafu(display("The WebSocket worker panicked: {}", text))]
     WebSocketTaskPanic { text: String },
+
+    #[snafu(display("Unable to create the coordinator"))]
+    CreateCoordinator {
+        source: orchestrator::coordinator::Error,
+    },
+
+    #[snafu(display("Unable to shutdown the coordinator"))]
+    ShutdownCoordinator {
+        source: orchestrator::coordinator::Error,
+    },
+
+    #[snafu(display("Unable to convert the compile request"))]
+    Compile {
+        source: orchestrator::coordinator::CompileError,
+    },
+
+    #[snafu(display("The operation timed out"))]
+    Timeout { source: tokio::time::error::Elapsed },
 }
 
 type Result<T, E = Error> = ::std::result::Result<T, E>;

ui/src/main.rs

@@ -1,11 +1,15 @@
 use futures::future::BoxFuture;
 use lazy_static::lazy_static;
+use orchestrator::coordinator;
 use prometheus::{
     self, register_histogram, register_histogram_vec, register_int_counter, register_int_gauge,
     Histogram, HistogramVec, IntCounter, IntGauge,
 };
 use regex::Regex;
-use std::{future::Future, time::Instant};
+use std::{
+    future::Future,
+    time::{Duration, Instant},
+};
 
 use crate::sandbox::{self, Channel, CompileTarget, CrateType, Edition, Mode};
 
@@ -62,6 +66,16 @@ pub(crate) enum Outcome {
     ErrorUserCode,
 }
 
+pub(crate) struct LabelsCore {
+    target: Option<CompileTarget>,
+    channel: Option<Channel>,
+    mode: Option<Mode>,
+    edition: Option<Option<Edition>>,
+    crate_type: Option<CrateType>,
+    tests: Option<bool>,
+    backtrace: Option<bool>,
+}
+
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct Labels {
     endpoint: Endpoint,
@@ -132,6 +146,29 @@ impl Labels {
             backtrace,
         ]
     }
+
+    pub(crate) fn complete(endpoint: Endpoint, labels_core: LabelsCore, outcome: Outcome) -> Self {
+        let LabelsCore {
+            target,
+            channel,
+            mode,
+            edition,
+            crate_type,
+            tests,
+            backtrace,
+        } = labels_core;
+        Self {
+            endpoint,
+            outcome,
+            target,
+            channel,
+            mode,
+            edition,
+            crate_type,
+            tests,
+            backtrace,
+        }
+    }
 }
 
 pub(crate) trait GenerateLabels {
@@ -406,11 +443,8 @@ where
     let outcome = SuccessDetails::for_sandbox_result(&response);
     let mut labels = request.generate_labels(outcome);
     f(&mut labels);
-    let values = &labels.as_values();
-
-    let histogram = REQUESTS.with_label_values(values);
 
-    histogram.observe(elapsed.as_secs_f64());
+    record_metric_complete(labels, elapsed);
 
     response
 }
@@ -443,10 +477,53 @@ where
         tests: None,
         backtrace: None,
     };
-    let values = &labels.as_values();
-    let histogram = REQUESTS.with_label_values(values);
 
-    histogram.observe(elapsed.as_secs_f64());
+    record_metric_complete(labels, elapsed);
 
     response
 }
+
+pub(crate) trait HasLabelsCore {
+    fn labels_core(&self) -> LabelsCore;
+}
+
+impl HasLabelsCore for coordinator::CompileRequest {
+    fn labels_core(&self) -> LabelsCore {
+        let Self {
+            target,
+            channel,
+            crate_type,
+            mode,
+            edition,
+            tests,
+            backtrace,
+            code: _,
+        } = *self;
+
+        LabelsCore {
+            target: Some(target.into()),
+            channel: Some(channel.into()),
+            mode: Some(mode.into()),
+            edition: Some(Some(edition.into())),
+            crate_type: Some(crate_type.into()),
+            tests: Some(tests),
+            backtrace: Some(backtrace),
+        }
+    }
+}
+
+pub(crate) fn record_metric(
+    endpoint: Endpoint,
+    labels_core: LabelsCore,
+    outcome: Outcome,
+    elapsed: Duration,
+) {
+    let labels = Labels::complete(endpoint, labels_core, outcome);
+    record_metric_complete(labels, elapsed)
+}
+
+fn record_metric_complete(labels: Labels, elapsed: Duration) {
+    let values = &labels.as_values();
+    let histogram = REQUESTS.with_label_values(values);
+    histogram.observe(elapsed.as_secs_f64());
+}