Move Error into server_axum module

shepmaster · shepmaster · commit 6dff52b91350 · 2024-06-08T09:03:32.000-04:00
diff --git a/ui/src/main.rs b/ui/src/main.rs
@@ -1,7 +1,6 @@
 #![deny(rust_2018_idioms)]
 
 use orchestrator::coordinator::CoordinatorFactory;
-use snafu::prelude::*;
 use std::{
     net::SocketAddr,
     path::{Path, PathBuf},
@@ -183,13 +182,6 @@ impl GhToken {
     fn new(token: &Option<String>) -> Self {
         GhToken(token.clone().map(Arc::new))
     }
-
-    fn must_get(&self) -> Result<String> {
-        self.0
-            .as_ref()
-            .map(|s| String::clone(s))
-            .context(NoGithubTokenSnafu)
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -200,131 +192,3 @@ impl MetricsToken {
         MetricsToken(Arc::new(token.into()))
     }
 }
-
-#[derive(Debug, Snafu)]
-enum Error {
-    #[snafu(display("Gist creation failed: {}", source))]
-    GistCreation { source: octocrab::Error },
-    #[snafu(display("Gist loading failed: {}", source))]
-    GistLoading { source: octocrab::Error },
-    #[snafu(display("{PLAYGROUND_GITHUB_TOKEN} not set up for reading/writing gists"))]
-    NoGithubToken,
-    #[snafu(display("Unable to deserialize request: {}", source))]
-    Deserialization { source: serde_json::Error },
-
-    #[snafu(transparent)]
-    EvaluateRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseEvaluateRequestError,
-    },
-
-    #[snafu(transparent)]
-    CompileRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseCompileRequestError,
-    },
-
-    #[snafu(transparent)]
-    ExecuteRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseExecuteRequestError,
-    },
-
-    #[snafu(transparent)]
-    FormatRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseFormatRequestError,
-    },
-
-    #[snafu(transparent)]
-    ClippyRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseClippyRequestError,
-    },
-
-    #[snafu(transparent)]
-    MiriRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseMiriRequestError,
-    },
-
-    #[snafu(transparent)]
-    MacroExpansionRequest {
-        source: server_axum::api_orchestrator_integration_impls::ParseMacroExpansionRequestError,
-    },
-
-    #[snafu(display("The WebSocket worker panicked: {}", text))]
-    WebSocketTaskPanic { text: String },
-
-    #[snafu(display("Unable to find the available crates"))]
-    Crates {
-        source: orchestrator::coordinator::CratesError,
-    },
-
-    #[snafu(display("Unable to find the available versions"))]
-    Versions {
-        source: orchestrator::coordinator::VersionsError,
-    },
-
-    #[snafu(display("The Miri version was missing"))]
-    MiriVersion,
-
-    #[snafu(display("Unable to shutdown the coordinator"))]
-    ShutdownCoordinator {
-        source: orchestrator::coordinator::Error,
-    },
-
-    #[snafu(display("Unable to process the evaluate request"))]
-    Evaluate {
-        source: orchestrator::coordinator::ExecuteError,
-    },
-
-    #[snafu(display("Unable to process the compile request"))]
-    Compile {
-        source: orchestrator::coordinator::CompileError,
-    },
-
-    #[snafu(display("Unable to process the execute request"))]
-    Execute {
-        source: orchestrator::coordinator::ExecuteError,
-    },
-
-    #[snafu(display("Unable to process the format request"))]
-    Format {
-        source: orchestrator::coordinator::FormatError,
-    },
-
-    #[snafu(display("Unable to process the Clippy request"))]
-    Clippy {
-        source: orchestrator::coordinator::ClippyError,
-    },
-
-    #[snafu(display("Unable to process the Miri request"))]
-    Miri {
-        source: orchestrator::coordinator::MiriError,
-    },
-
-    #[snafu(display("Unable to process the macro expansion request"))]
-    MacroExpansion {
-        source: orchestrator::coordinator::MacroExpansionError,
-    },
-
-    #[snafu(display("The operation timed out"))]
-    Timeout { source: tokio::time::error::Elapsed },
-
-    #[snafu(display("Unable to spawn a coordinator task"))]
-    StreamingCoordinatorSpawn {
-        source: server_axum::WebsocketCoordinatorManagerError,
-    },
-
-    #[snafu(display("Unable to idle the coordinator"))]
-    StreamingCoordinatorIdle {
-        source: server_axum::WebsocketCoordinatorManagerError,
-    },
-
-    #[snafu(display("Unable to perform a streaming execute"))]
-    StreamingExecute {
-        source: server_axum::WebsocketExecuteError,
-    },
-
-    #[snafu(display("Unable to pass stdin to the active execution"))]
-    StreamingCoordinatorExecuteStdin {
-        source: tokio::sync::mpsc::error::SendError<()>,
-    },
-}
-
-type Result<T, E = Error> = ::std::result::Result<T, E>;
diff --git a/ui/src/metrics.rs b/ui/src/metrics.rs
@@ -207,13 +207,13 @@ impl Labels {
     }
 }
 
-pub(crate) async fn track_metric_no_request_async<B, Fut, Resp>(
+pub(crate) async fn track_metric_no_request_async<B, Fut, Resp, E>(
     endpoint: Endpoint,
     body: B,
-) -> crate::Result<Resp>
+) -> Result<Resp, E>
 where
     B: FnOnce() -> Fut,
-    Fut: Future<Output = crate::Result<Resp>>,
+    Fut: Future<Output = Result<Resp, E>>,
 {
     let start = Instant::now();
     let response = body().await;
diff --git a/ui/src/server_axum.rs b/ui/src/server_axum.rs
@@ -5,9 +5,7 @@ use crate::{
         ONE_OFF_QUEUE_DEPTH, UNAVAILABLE_WS,
     },
     request_database::{Handle, How},
-    ClippySnafu, CompileSnafu, Config, CratesSnafu, Error, EvaluateSnafu, ExecuteSnafu,
-    FormatSnafu, GhToken, GistCreationSnafu, GistLoadingSnafu, MacroExpansionSnafu, MetricsToken,
-    MiriSnafu, MiriVersionSnafu, Result, ShutdownCoordinatorSnafu, TimeoutSnafu, VersionsSnafu,
+    Config, GhToken, MetricsToken,
 };
 use async_trait::async_trait;
 use axum::{
@@ -48,7 +46,7 @@ use tower_http::{
 };
 use tracing::{error, error_span, field};
 
-use crate::public_http_api as api;
+use crate::{env::PLAYGROUND_GITHUB_TOKEN, public_http_api as api};
 
 const ONE_HOUR: Duration = Duration::from_secs(60 * 60);
 const CORS_CACHE_TIME_TO_LIVE: Duration = ONE_HOUR;
@@ -608,11 +606,19 @@ where
     Ok((etag, cache_control, response))
 }
 
+fn must_get(token: &GhToken) -> Result<String> {
+    token
+        .0
+        .as_ref()
+        .map(|s| String::clone(s))
+        .context(NoGithubTokenSnafu)
+}
+
 async fn meta_gist_create(
     Extension(token): Extension<GhToken>,
     Json(req): Json<api::MetaGistCreateRequest>,
 ) -> Result<Json<api::MetaGistResponse>> {
-    let token = token.must_get()?;
+    let token = must_get(&token)?;
     gist::create_future(token, req.code)
         .await
         .map(Into::into)
@@ -624,7 +630,7 @@ async fn meta_gist_get(
     Extension(token): Extension<GhToken>,
     Path(id): Path<String>,
 ) -> Result<Json<api::MetaGistResponse>> {
-    let token = token.must_get()?;
+    let token = must_get(&token)?;
     gist::load_future(token, &id)
         .await
         .map(Into::into)
@@ -980,6 +986,135 @@ where
     }
 }
 
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Gist creation failed"))]
+    GistCreation { source: octocrab::Error },
+
+    #[snafu(display("Gist loading failed"))]
+    GistLoading { source: octocrab::Error },
+
+    #[snafu(display("{PLAYGROUND_GITHUB_TOKEN} not set up for reading/writing gists"))]
+    NoGithubToken,
+
+    #[snafu(display("Unable to deserialize request"))]
+    Deserialization { source: serde_json::Error },
+
+    #[snafu(transparent)]
+    EvaluateRequest {
+        source: api_orchestrator_integration_impls::ParseEvaluateRequestError,
+    },
+
+    #[snafu(transparent)]
+    CompileRequest {
+        source: api_orchestrator_integration_impls::ParseCompileRequestError,
+    },
+
+    #[snafu(transparent)]
+    ExecuteRequest {
+        source: api_orchestrator_integration_impls::ParseExecuteRequestError,
+    },
+
+    #[snafu(transparent)]
+    FormatRequest {
+        source: api_orchestrator_integration_impls::ParseFormatRequestError,
+    },
+
+    #[snafu(transparent)]
+    ClippyRequest {
+        source: api_orchestrator_integration_impls::ParseClippyRequestError,
+    },
+
+    #[snafu(transparent)]
+    MiriRequest {
+        source: api_orchestrator_integration_impls::ParseMiriRequestError,
+    },
+
+    #[snafu(transparent)]
+    MacroExpansionRequest {
+        source: api_orchestrator_integration_impls::ParseMacroExpansionRequestError,
+    },
+
+    #[snafu(display("The WebSocket worker panicked: {}", text))]
+    WebSocketTaskPanic { text: String },
+
+    #[snafu(display("Unable to find the available crates"))]
+    Crates {
+        source: orchestrator::coordinator::CratesError,
+    },
+
+    #[snafu(display("Unable to find the available versions"))]
+    Versions {
+        source: orchestrator::coordinator::VersionsError,
+    },
+
+    #[snafu(display("The Miri version was missing"))]
+    MiriVersion,
+
+    #[snafu(display("Unable to shutdown the coordinator"))]
+    ShutdownCoordinator {
+        source: orchestrator::coordinator::Error,
+    },
+
+    #[snafu(display("Unable to process the evaluate request"))]
+    Evaluate {
+        source: orchestrator::coordinator::ExecuteError,
+    },
+
+    #[snafu(display("Unable to process the compile request"))]
+    Compile {
+        source: orchestrator::coordinator::CompileError,
+    },
+
+    #[snafu(display("Unable to process the execute request"))]
+    Execute {
+        source: orchestrator::coordinator::ExecuteError,
+    },
+
+    #[snafu(display("Unable to process the format request"))]
+    Format {
+        source: orchestrator::coordinator::FormatError,
+    },
+
+    #[snafu(display("Unable to process the Clippy request"))]
+    Clippy {
+        source: orchestrator::coordinator::ClippyError,
+    },
+
+    #[snafu(display("Unable to process the Miri request"))]
+    Miri {
+        source: orchestrator::coordinator::MiriError,
+    },
+
+    #[snafu(display("Unable to process the macro expansion request"))]
+    MacroExpansion {
+        source: orchestrator::coordinator::MacroExpansionError,
+    },
+
+    #[snafu(display("The operation timed out"))]
+    Timeout { source: tokio::time::error::Elapsed },
+
+    #[snafu(display("Unable to spawn a coordinator task"))]
+    StreamingCoordinatorSpawn {
+        source: WebsocketCoordinatorManagerError,
+    },
+
+    #[snafu(display("Unable to idle the coordinator"))]
+    StreamingCoordinatorIdle {
+        source: WebsocketCoordinatorManagerError,
+    },
+
+    #[snafu(display("Unable to perform a streaming execute"))]
+    StreamingExecute { source: WebsocketExecuteError },
+
+    #[snafu(display("Unable to pass stdin to the active execution"))]
+    StreamingCoordinatorExecuteStdin {
+        source: tokio::sync::mpsc::error::SendError<()>,
+    },
+}
+
+type Result<T, E = Error> = ::std::result::Result<T, E>;
+
 pub(crate) mod api_orchestrator_integration_impls {
     use orchestrator::coordinator::*;
     use snafu::prelude::*;
diff --git a/ui/src/server_axum/websocket.rs b/ui/src/server_axum/websocket.rs
@@ -2,8 +2,6 @@ use crate::{
     metrics::{self, record_metric, Endpoint, HasLabelsCore, Outcome},
     request_database::{Handle, How},
     server_axum::api_orchestrator_integration_impls::*,
-    Error, Result, StreamingCoordinatorExecuteStdinSnafu, StreamingCoordinatorIdleSnafu,
-    StreamingCoordinatorSpawnSnafu, StreamingExecuteSnafu, WebSocketTaskPanicSnafu,
 };
 
 use axum::extract::ws::{Message, WebSocket};
@@ -32,6 +30,12 @@ use tokio::{
 use tokio_util::sync::CancellationToken;
 use tracing::{error, instrument, warn, Instrument};
 
+use super::{
+    DeserializationSnafu, Error, Result, StreamingCoordinatorExecuteStdinSnafu,
+    StreamingCoordinatorIdleSnafu, StreamingCoordinatorSpawnSnafu, StreamingExecuteSnafu,
+    WebSocketTaskPanicSnafu,
+};
+
 #[derive(Debug, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 struct MetaInner {
@@ -533,7 +537,7 @@ async fn handle_msg(
 ) {
     use WSMessageRequest::*;
 
-    let msg = serde_json::from_str(&txt).context(crate::DeserializationSnafu);
+    let msg = serde_json::from_str(&txt).context(DeserializationSnafu);
 
     match msg {
         Ok(ExecuteRequest { payload, meta }) => {

Original file line number	Diff line number	Diff line change
`@@ -207,13 +207,13 @@ impl Labels {`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`
`210`		`-pub(crate) async fn track_metric_no_request_async<B, Fut, Resp>(`
	`210`	`+pub(crate) async fn track_metric_no_request_async<B, Fut, Resp, E>(`
`211`	`211`	`endpoint: Endpoint,`
`212`	`212`	`body: B,`
`213`		`-) -> crate::Result<Resp>`
	`213`	`+) -> Result<Resp, E>`
`214`	`214`	`where`
`215`	`215`	`B: FnOnce() -> Fut,`
`216`		`- Fut: Future<Output = crate::Result<Resp>>,`
	`216`	`+ Fut: Future<Output = Result<Resp, E>>,`
`217`	`217`	`{`
`218`	`218`	`let start = Instant::now();`
`219`	`219`	`let response = body().await;`