Migrate metrics to coordinator types

Author: shepmaster

ui/src/metrics.rs

@@ -1,5 +1,5 @@
 use lazy_static::lazy_static;
-use orchestrator::coordinator;
+use orchestrator::coordinator::{self, Channel, CompileTarget, CrateType, Edition, Mode};
 use prometheus::{
     self, register_histogram, register_histogram_vec, register_int_counter,
     register_int_counter_vec, register_int_gauge, Histogram, HistogramVec, IntCounter,
@@ -10,7 +10,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use crate::sandbox::{self, Channel, CompileTarget, CrateType, Edition, Mode};
+use crate::sandbox;
 
 lazy_static! {
     pub(crate) static ref REQUESTS: HistogramVec = register_histogram_vec!(
@@ -132,15 +132,38 @@ impl Labels {
             v.map_or("", |v| if v { "true" } else { "false" })
         }
 
-        let target = target.map_or("", Into::into);
-        let channel = channel.map_or("", Into::into);
-        let mode = mode.map_or("", Into::into);
+        let target = match target {
+            Some(CompileTarget::Assembly(_, _, _)) => "Assembly",
+            Some(CompileTarget::Hir) => "Hir",
+            Some(CompileTarget::LlvmIr) => "LlvmIr",
+            Some(CompileTarget::Mir) => "Mir",
+            Some(CompileTarget::Wasm) => "Wasm",
+            None => "",
+        };
+        let channel = match channel {
+            Some(Channel::Stable) => "Stable",
+            Some(Channel::Beta) => "Beta",
+            Some(Channel::Nightly) => "Nightly",
+            None => "",
+        };
+        let mode = match mode {
+            Some(Mode::Debug) => "Debug",
+            Some(Mode::Release) => "Release",
+            None => "",
+        };
         let edition = match edition {
             None => "",
             Some(None) => "Unspecified",
-            Some(Some(v)) => v.into(),
+            Some(Some(Edition::Rust2015)) => "Rust2015",
+            Some(Some(Edition::Rust2018)) => "Rust2018",
+            Some(Some(Edition::Rust2021)) => "Rust2021",
+            Some(Some(Edition::Rust2024)) => "Rust2024",
+        };
+        let crate_type = match crate_type {
+            Some(CrateType::Binary) => "Binary",
+            Some(CrateType::Library(_)) => "Library",
+            None => "",
         };
-        let crate_type = crate_type.map_or("", Into::into);
         let tests = b(tests);
         let backtrace = b(backtrace);
 
@@ -262,11 +285,11 @@ impl HasLabelsCore for coordinator::CompileRequest {
         } = *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()),
+            target: Some(target),
+            channel: Some(channel),
+            mode: Some(mode),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: Some(tests),
             backtrace: Some(backtrace),
         }
@@ -287,10 +310,10 @@ impl HasLabelsCore for coordinator::ExecuteRequest {
 
         LabelsCore {
             target: None,
-            channel: Some(channel.into()),
-            mode: Some(mode.into()),
-            edition: Some(Some(edition.into())),
-            crate_type: Some(crate_type.into()),
+            channel: Some(channel),
+            mode: Some(mode),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: Some(tests),
             backtrace: Some(backtrace),
         }
@@ -308,10 +331,10 @@ impl HasLabelsCore for coordinator::FormatRequest {
 
         LabelsCore {
             target: None,
-            channel: Some(channel.into()),
+            channel: Some(channel),
             mode: None,
-            edition: Some(Some(edition.into())),
-            crate_type: Some(crate_type.into()),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: None,
             backtrace: None,
         }
@@ -329,10 +352,10 @@ impl HasLabelsCore for coordinator::ClippyRequest {
 
         LabelsCore {
             target: None,
-            channel: Some(channel.into()),
+            channel: Some(channel),
             mode: None,
-            edition: Some(Some(edition.into())),
-            crate_type: Some(crate_type.into()),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: None,
             backtrace: None,
         }
@@ -350,10 +373,10 @@ impl HasLabelsCore for coordinator::MiriRequest {
 
         LabelsCore {
             target: None,
-            channel: Some(channel.into()),
+            channel: Some(channel),
             mode: None,
-            edition: Some(Some(edition.into())),
-            crate_type: Some(crate_type.into()),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: None,
             backtrace: None,
         }
@@ -371,10 +394,10 @@ impl HasLabelsCore for coordinator::MacroExpansionRequest {
 
         LabelsCore {
             target: None,
-            channel: Some(channel.into()),
+            channel: Some(channel),
             mode: None,
-            edition: Some(Some(edition.into())),
-            crate_type: Some(crate_type.into()),
+            edition: Some(Some(edition)),
+            crate_type: Some(crate_type),
             tests: None,
             backtrace: None,
         }

ui/src/sandbox.rs

@@ -473,100 +473,3 @@ impl<R: BacktraceRequest> BacktraceRequest for &'_ R {
         (*self).backtrace()
     }
 }
-
-mod sandbox_orchestrator_integration_impls {
-    use orchestrator::coordinator;
-
-    impl From<coordinator::CompileTarget> for super::CompileTarget {
-        fn from(value: coordinator::CompileTarget) -> Self {
-            match value {
-                coordinator::CompileTarget::Assembly(a, b, c) => {
-                    super::CompileTarget::Assembly(a.into(), b.into(), c.into())
-                }
-                coordinator::CompileTarget::Hir => super::CompileTarget::Hir,
-                coordinator::CompileTarget::LlvmIr => super::CompileTarget::LlvmIr,
-                coordinator::CompileTarget::Mir => super::CompileTarget::Mir,
-                coordinator::CompileTarget::Wasm => super::CompileTarget::Wasm,
-            }
-        }
-    }
-
-    impl From<coordinator::Mode> for super::Mode {
-        fn from(value: coordinator::Mode) -> Self {
-            match value {
-                coordinator::Mode::Debug => super::Mode::Debug,
-                coordinator::Mode::Release => super::Mode::Release,
-            }
-        }
-    }
-
-    impl From<coordinator::Edition> for super::Edition {
-        fn from(value: coordinator::Edition) -> Self {
-            match value {
-                coordinator::Edition::Rust2015 => super::Edition::Rust2015,
-                coordinator::Edition::Rust2018 => super::Edition::Rust2018,
-                coordinator::Edition::Rust2021 => super::Edition::Rust2021,
-                coordinator::Edition::Rust2024 => super::Edition::Rust2024,
-            }
-        }
-    }
-
-    impl From<coordinator::Channel> for super::Channel {
-        fn from(value: coordinator::Channel) -> Self {
-            match value {
-                coordinator::Channel::Stable => super::Channel::Stable,
-                coordinator::Channel::Beta => super::Channel::Beta,
-                coordinator::Channel::Nightly => super::Channel::Nightly,
-            }
-        }
-    }
-
-    impl From<coordinator::AssemblyFlavor> for super::AssemblyFlavor {
-        fn from(value: coordinator::AssemblyFlavor) -> Self {
-            match value {
-                coordinator::AssemblyFlavor::Att => super::AssemblyFlavor::Att,
-                coordinator::AssemblyFlavor::Intel => super::AssemblyFlavor::Intel,
-            }
-        }
-    }
-
-    impl From<coordinator::CrateType> for super::CrateType {
-        fn from(value: coordinator::CrateType) -> Self {
-            match value {
-                coordinator::CrateType::Binary => super::CrateType::Binary,
-                coordinator::CrateType::Library(a) => super::CrateType::Library(a.into()),
-            }
-        }
-    }
-
-    impl From<coordinator::DemangleAssembly> for super::DemangleAssembly {
-        fn from(value: coordinator::DemangleAssembly) -> Self {
-            match value {
-                coordinator::DemangleAssembly::Demangle => super::DemangleAssembly::Demangle,
-                coordinator::DemangleAssembly::Mangle => super::DemangleAssembly::Mangle,
-            }
-        }
-    }
-
-    impl From<coordinator::ProcessAssembly> for super::ProcessAssembly {
-        fn from(value: coordinator::ProcessAssembly) -> Self {
-            match value {
-                coordinator::ProcessAssembly::Filter => super::ProcessAssembly::Filter,
-                coordinator::ProcessAssembly::Raw => super::ProcessAssembly::Raw,
-            }
-        }
-    }
-
-    impl From<coordinator::LibraryType> for super::LibraryType {
-        fn from(value: coordinator::LibraryType) -> Self {
-            match value {
-                coordinator::LibraryType::Lib => super::LibraryType::Lib,
-                coordinator::LibraryType::Dylib => super::LibraryType::Dylib,
-                coordinator::LibraryType::Rlib => super::LibraryType::Rlib,
-                coordinator::LibraryType::Staticlib => super::LibraryType::Staticlib,
-                coordinator::LibraryType::Cdylib => super::LibraryType::Cdylib,
-                coordinator::LibraryType::ProcMacro => super::LibraryType::ProcMacro,
-            }
-        }
-    }
-}