wip: json errors

Cargo.toml

@@ -20,3 +20,5 @@ http = "1.1.0"
 tokio-util = { version = "0.7.11", features = ["io"] }
 futures-util = "0.3.30"
 infer = "0.15.0"
+tower = { version = "0.4.13", features = ["timeout"] }
+tower-service = "0.3.2"

src/json_error.rs

@@ -0,0 +1,47 @@
+use tower::Layer;
+
+use crate::json_error::private::JsonErrorService;
+
+#[derive(Debug, Clone)]
+#[must_use]
+pub struct JsonError;
+
+impl<S> Layer<S> for JsonError {
+    type Service = JsonErrorService<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        JsonErrorService { inner }
+    }
+}
+
+mod private {
+    use std::task::Context;
+
+    use http::Request;
+    use tower_service::Service;
+
+    #[derive(Debug, Clone, Copy)]
+    pub struct JsonErrorService<S> {
+        pub(super) inner: S,
+    }
+
+    impl<B, S> Service<Request<B>> for JsonErrorService<S>
+        where
+            S: Service<Request<B>>,
+    {
+        type Response = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+
+        #[inline]
+        fn poll_ready(&mut self, cx: &mut Context<'_>) -> std::task::Poll<Result<(), Self::Error>> {
+            self.inner.poll_ready(cx)
+        }
+
+        #[inline]
+        fn call(&mut self, mut req: Request<B>) -> Self::Future {
+            let response = self.inner.call(req);
+            response
+        }
+    }
+}

src/main.rs

@@ -11,6 +11,7 @@ mod server;
 mod task;
 mod thread_pool;
 mod transcoder;
+mod json_error;
 
 const WORK_DIR_IN_OUT_LIFETIME: u64 = 60 * 60;
 

src/server.rs

@@ -1,33 +1,35 @@
 use std::env;
 use std::ffi::OsStr;
+use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
+use axum::{Json, Router};
+use axum::body::Body;
+use axum::body::Bytes;
 use axum::extract::{DefaultBodyLimit, Path, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::routing::{get, post};
-use axum::{Json, Router};
 use axum_typed_multipart::TypedMultipart;
+use futures_util::StreamExt;
 use tokio::fs;
+use tokio::fs::File;
+use tokio::io::AsyncReadExt;
 use tokio::net::TcpListener;
 use tokio::time::interval;
+use tokio_util::io::ReaderStream;
+use tower::ServiceBuilder;
 use tower_http::trace::TraceLayer;
 use tracing::{debug, error};
 use uuid::Uuid;
 
 use crate::dto::{ConvertRequest, ConvertResponse, ConvertURLRequest, ErrorResponse};
-use crate::task::{Task, TaskParams};
-use crate::thread_pool::ThreadPool;
 
 use crate::filepath;
 use crate::filepath::{in_file_path, out_file_path};
-use axum::body::Body;
+use crate::json_error::JsonError;
-use axum::body::Bytes;
+use crate::task::{Task, TaskParams};
-use futures_util::StreamExt;
+use crate::thread_pool::ThreadPool;
-use std::sync::Arc;
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use tokio_util::io::ReaderStream;
 
 const CONTENT_LENGTH_LIMIT: usize = 100 * 1024 * 1024;
 
@@ -73,7 +75,11 @@ impl Server {
             .route("/enqueue_url", post(enqueue_url))
             .route("/get/:identifier", get(download_file))
             .with_state(this)
+            .layer(
+                ServiceBuilder::new()
                     .layer(TraceLayer::new_for_http())
+                    .layer(JsonError)
+            )
             .fallback(handler_not_found);
 
         tracing::info!("listening on {addr}");