adview serve:

- new preview route
- improved Manager for random position generation

Author: elpiel

adview-manager/README.md

@@ -12,7 +12,7 @@ a publisher websites.
 
 Running the local server:
 
-`RUST_LOG=debug cargo run -p serve`
+`RUST_LOG=debug cargo run -p adview-serve`
 
 This will start a server at `127.0.0.1:3030`
 
@@ -21,4 +21,7 @@ for the server.
 
 Routes:
 
-- `GET /ad` - visualizes a single ad
+- `GET /` - landing page
+- `GET /preview/ad` - preview a single example ad
+- `GET /preview/video` - preview a single example ad
+- `POST /:slot` - preview a single example ad

adview-manager/serve/src/app.rs

@@ -1,11 +1,18 @@
 use std::{net::SocketAddr, sync::Arc};
 
-use axum::{routing::get, Extension, Router, Server};
-use log::info;
+use axum::{
+    http::StatusCode,
+    response::IntoResponse,
+    routing::{get, post},
+    Extension, Router, Server,
+};
+use tracing::{error, info};
 
 use tera::Tera;
 
-use crate::routes::{get_index, get_preview_ad, get_preview_video};
+use crate::routes::{
+    get_index, get_preview_ad, get_preview_video, post_slot_preview,
+};
 
 #[derive(Debug)]
 pub struct State {
@@ -17,6 +24,68 @@ pub struct Application {
     state: Arc<State>,
 }
 
+pub struct Error {
+    error: Box<dyn std::error::Error>,
+    status: StatusCode,
+}
+
+impl Error {
+    pub fn new<E>(error: E, status: StatusCode) -> Self
+    where
+        E: Into<Box<dyn std::error::Error>>,
+    {
+        Self {
+            error: error.into(),
+            status,
+        }
+    }
+
+    /// Create a new [`Error`] from [`anyhow::Error`] with a custom [`StatusCode`]
+    /// instead of the default [`StatusCode::INTERNAL_SERVER_ERROR`].
+    pub fn anyhow_status(error: anyhow::Error, status: StatusCode) -> Self {
+        Self {
+            error: error.into(),
+            status,
+        }
+    }
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> axum::response::Response {
+        let response_tuple = match self.status {
+            StatusCode::INTERNAL_SERVER_ERROR => {
+                error!({error = %self.error}, "Server error");
+                (StatusCode::INTERNAL_SERVER_ERROR, self.error.to_string())
+            }
+            // we want to log any error that is with status > 500
+            status_code if status_code.as_u16() > 500 => {
+                error!({error = %self.error}, "Server error");
+                (status_code, self.error.to_string())
+            },
+            // anything else is < 500, so it's safe to not log it due to e.g. bad user input
+            status_code => {
+                (status_code, self.error.to_string())
+            }
+        };
+
+        response_tuple.into_response()
+    }
+}
+
+impl<E> From<E> for Error
+where
+    E: Into<anyhow::Error>,
+{
+    fn from(err: E) -> Self {
+        let anyhow_err: anyhow::Error = err.into();
+
+        Self {
+            error: anyhow_err.into(),
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
 impl Application {
     pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
         let serve_dir = match std::env::current_dir().unwrap() {
@@ -42,11 +111,15 @@ impl Application {
     }
 
     pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
+        let preview_routes = Router::new()
+            .route("/", post(post_slot_preview))
+            .route("/ad", get(get_preview_ad))
+            .route("/video", get(get_preview_video));
+
         // build our application with a single route
         let app = Router::new()
             .route("/", get(get_index))
-            .route("/preview/ad", get(get_preview_ad))
-            .route("/preview/video", get(get_preview_video))
+            .nest("/preview", preview_routes)
             .layer(Extension(self.state.clone()));
 
         let socket_addr: SocketAddr = ([127, 0, 0, 1], 3030).into();