feat: add api axum based handlers (ongoing)

dasch-swiss · Sep 25, 2023 · a99cc26 · a99cc26
1 parent cb8fee3
commit a99cc26
Show file tree

Hide file tree

Showing 13 changed files with 166 additions and 69 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,7 @@ serde_json = "1" # JSON serialization
 tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
 tokio-test = "0.4.2"
 tower = "0.4.13"
+tower-http = { version = "0.4.0", features = ["trace"] }
 hyper = "0.14.27"
 tracing = "0.1"
 tracing-subscriber = "0.3"
@@ -51,6 +52,7 @@ serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true
 tower.workspace = true
+tower-http.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 tracing-test.workspace = true

diff --git a/src/bin/dsp_meta_server/main.rs b/src/bin/dsp_meta_server/main.rs
@@ -1,9 +1,6 @@
 use std::sync::Arc;
 
-use axum::routing::{get, post};
-use axum::Router;
-use dsp_meta::api::project_metadata_handler;
-use dsp_meta::app_state::app_state::AppState;
+use dsp_meta::app_state::AppState;
 use dsp_meta::repo::project_metadata_repository::ProjectMetadataRepository;
 use dsp_meta::service::project_metadata_service::ProjectMetadataService;
 use tracing::{trace, Level};
@@ -28,58 +25,7 @@ async fn main() {
 
     // run it with hyper on localhost:3000
     axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
-        .serve(app(shared_state).into_make_service())
+        .serve(dsp_meta::api::app::app(shared_state).into_make_service())
         .await
         .unwrap();
 }
-
-/// Having a function that produces our app makes it easy to call it from tests
-/// without having to create an HTTP server.
-fn app(shared_state: Arc<AppState>) -> Router {
-    Router::new()
-        .route(
-            "/",
-            get(project_metadata_handler::get_root).post(project_metadata_handler::post_root),
-        )
-        .route("/hello_world", get(project_metadata_handler::hello_world))
-        .route("/foo/bar", get(project_metadata_handler::foo_bar))
-        // `POST /users` goes to `create_user`
-        .route("/users", post(project_metadata_handler::create_user))
-        .with_state(shared_state)
-}
-
-#[cfg(test)]
-mod tests {
-    use axum::body::Body;
-    use axum::http::{Request, StatusCode};
-    // use tower::Service; // for `call`
-    use tower::ServiceExt; // for `oneshot` and `ready`
-
-    use super::*;
-
-    #[tokio::test]
-    async fn hello_world() {
-        let shared_state = Arc::new(AppState {
-            project_metadata_service: ProjectMetadataService::new(ProjectMetadataRepository::new()),
-        });
-
-        let app = app(shared_state);
-
-        // `Router` implements `tower::Service<Request<Body>>` so we can
-        // call it like any tower service, no need to run an HTTP server.
-        let response = app
-            .oneshot(
-                Request::builder()
-                    .uri("/hello_world")
-                    .body(Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
-        assert_eq!(&body[..], b"Hello, World!");
-    }
-}
diff --git a/src/dsp_meta/api/app.rs b/src/dsp_meta/api/app.rs
@@ -0,0 +1,113 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use axum::body::Bytes;
+use axum::extract::MatchedPath;
+use axum::http::{HeaderMap, Request};
+use axum::response::Response;
+use axum::routing::{get, post};
+use axum::Router;
+use tower_http::classify::ServerErrorsFailureClass;
+use tower_http::trace::TraceLayer;
+use tracing::{info_span, Span};
+
+use crate::api::project_metadata_handler;
+use crate::app_state::AppState;
+
+/// Having a function that produces our app makes it easy to call it from tests
+/// without having to create an HTTP server.
+pub fn app(shared_state: Arc<AppState>) -> Router {
+    Router::new()
+        .route(
+            "/",
+            get(project_metadata_handler::get_root).post(project_metadata_handler::post_root),
+        )
+        .route("/hello_world", get(project_metadata_handler::hello_world))
+        .route("/foo/bar", get(project_metadata_handler::foo_bar))
+        // `POST /users` goes to `create_user`
+        .route("/users", post(project_metadata_handler::create_user))
+        .with_state(shared_state)
+        // `TraceLayer` is provided by tower-http so you have to add that as a dependency.
+        // It provides good defaults but is also very customizable.
+        //
+        // See https://docs.rs/tower-http/0.1.1/tower_http/trace/index.html for more details.
+        //
+        // If you want to customize the behavior using closures here is how.
+        .layer(
+            TraceLayer::new_for_http()
+                .make_span_with(|request: &Request<_>| {
+                    // Log the matched route's path (with placeholders not filled in).
+                    // Use request.uri() or OriginalUri if you want the real path.
+                    let matched_path = request
+                        .extensions()
+                        .get::<MatchedPath>()
+                        .map(MatchedPath::as_str);
+
+                    info_span!(
+                        "http_request",
+                        method = ?request.method(),
+                        matched_path,
+                        some_other_field = tracing::field::Empty,
+                    )
+                })
+                .on_request(|_request: &Request<_>, _span: &Span| {
+                    // You can use `_span.record("some_other_field", value)` in one of these
+                    // closures to attach a value to the initially empty field in the info_span
+                    // created above.
+                })
+                .on_response(|_response: &Response, _latency: Duration, _span: &Span| {
+                    // ...
+                })
+                .on_body_chunk(|_chunk: &Bytes, _latency: Duration, _span: &Span| {
+                    // ...
+                })
+                .on_eos(
+                    |_trailers: Option<&HeaderMap>, _stream_duration: Duration, _span: &Span| {
+                        // ...
+                    },
+                )
+                .on_failure(
+                    |_error: ServerErrorsFailureClass, _latency: Duration, _span: &Span| {
+                        // ...
+                    },
+                ),
+        )
+}
+
+#[cfg(test)]
+mod tests {
+    use axum::body::Body;
+    use axum::http::{Request, StatusCode};
+    // use tower::Service; // for `call`
+    use tower::ServiceExt; // for `oneshot` and `ready`
+
+    use super::*;
+    use crate::repo::project_metadata_repository::ProjectMetadataRepository;
+    use crate::service::project_metadata_service::ProjectMetadataService;
+
+    #[tokio::test]
+    async fn hello_world() {
+        let shared_state = Arc::new(AppState {
+            project_metadata_service: ProjectMetadataService::new(ProjectMetadataRepository::new()),
+        });
+
+        let app = app(shared_state);
+
+        // `Router` implements `tower::Service<Request<Body>>` so we can
+        // call it like any tower service, no need to run an HTTP server.
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/hello_world")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        assert_eq!(&body[..], b"Hello, World!");
+    }
+}
diff --git a/src/dsp_meta/api/mod.rs b/src/dsp_meta/api/mod.rs
@@ -1 +1,2 @@
+pub mod app;
 pub mod project_metadata_handler;
diff --git a/src/dsp_meta/api/project_metadata_handler.rs b/src/dsp_meta/api/project_metadata_handler.rs
@@ -1,13 +1,13 @@
 use std::sync::Arc;
 
-use axum::extract::State;
+use axum::extract::{Path, State};
 use axum::http::StatusCode;
 use axum::response::Json;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tracing::trace;
 
-use crate::app_state::app_state::AppState;
+use crate::app_state::AppState;
 use crate::domain::value::Shortcode;
 use crate::service::project_metadata_api_contract::ProjectMetadataApiContract;
 
@@ -17,7 +17,7 @@ use crate::service::project_metadata_api_contract::ProjectMetadataApiContract;
 /// TODO: Add error handling with correct status codes
 /// TODO: Add parameter extraction
 pub async fn get_project_metadata_by_shortcode(
-    shortcode: String,
+    Path(shortcode): Path<String>, // TODO: Change to Shortcode
     State(state): State<Arc<AppState>>,
 ) -> Json<Value> {
     trace!("entered dsp_meta::api::get_project_metadata_by_shortcode()");
@@ -57,13 +57,13 @@ pub async fn create_user(
 }
 
 // the input to our `create_user` handler
-#[derive(Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct CreateUser {
     username: String,
 }
 
 // the output to our `create_user` handler
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
 pub struct User {
     id: u64,
     username: String,

diff --git a/src/dsp_meta/app_state/app_state.rs → src/dsp_meta/app_state.rs b/src/dsp_meta/app_state/app_state.rs → src/dsp_meta/app_state.rs
@@ -1,7 +1,7 @@
 use crate::repo::project_metadata_repository::ProjectMetadataRepository;
 use crate::service::project_metadata_service::ProjectMetadataService;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct AppState {
     pub project_metadata_service: ProjectMetadataService<ProjectMetadataRepository>,
 }
diff --git a/src/dsp_meta/app_state/mod.rs b/src/dsp_meta/app_state/mod.rs
diff --git a/src/dsp_meta/domain/entity/dataset.rs b/src/dsp_meta/domain/entity/dataset.rs
@@ -1,7 +1,9 @@
+use serde::Serialize;
+
 use crate::domain::value::Title;
 use crate::errors::DspMetaError;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
 pub struct Dataset {
     pub title: Title,
 }

diff --git a/src/dsp_meta/domain/entity/person.rs b/src/dsp_meta/domain/entity/person.rs
@@ -1,4 +1,6 @@
-#[derive(Debug, Clone, Default, PartialEq)]
+use serde::Serialize;
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize)]
 pub struct Person {
     id: String,
 }
diff --git a/src/dsp_meta/domain/value/mod.rs b/src/dsp_meta/domain/value/mod.rs
@@ -44,5 +44,5 @@ pub struct EndDate(pub String);
 #[derive(Debug, Default, Clone, PartialEq, Serialize)]
 pub struct ContactPoint(pub String);
 
-#[derive(Debug, Default, Clone, PartialEq)]
+#[derive(Debug, Default, Clone, PartialEq, Serialize)]
 pub struct Title(pub String);
diff --git a/src/dsp_meta/repo/project_metadata_repository.rs b/src/dsp_meta/repo/project_metadata_repository.rs
@@ -8,7 +8,7 @@ use crate::domain::value::Shortcode;
 use crate::errors::DspMetaError;
 use crate::service::project_metadata_repository_contract::ProjectMetadataRepositoryContract;
 
-#[derive(Default, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct ProjectMetadataRepository {
     db: Arc<RwLock<HashMap<String, ProjectMetadata>>>,
 }

diff --git a/src/dsp_meta/service/project_metadata_service.rs b/src/dsp_meta/service/project_metadata_service.rs
@@ -6,7 +6,7 @@ use crate::errors::DspMetaError;
 use crate::service::project_metadata_api_contract::ProjectMetadataApiContract;
 use crate::service::project_metadata_repository_contract::ProjectMetadataRepositoryContract;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct ProjectMetadataService<R> {
     repo: R,
 }