feat: add some proper error handling

Reviewed-on: #109

.gitignore

@@ -1,2 +1,3 @@
 /target
 /data/
+*.tar.gz

.woodpecker/.build.yml

@@ -0,0 +1,10 @@
+platform: 'linux/amd64'
+branches:
+  exclude: [main]
+
+pipeline:
+  build:
+    image: 'rust:1.69-alpine3.16'
+    commands:
+      - apk add build-base
+      - cargo build 

.woodpecker/.deploy.yml

@@ -8,12 +8,10 @@ pipeline:
       repo: 'chewingbever/site'
       tag: 
         - 'latest'
-        - "${CI_COMMIT_TAG}"
+      mtu: 1300
     secrets:
       - 'docker_username'
       - 'docker_password'
-    when:
-      event: tag
 
   deploy:
     image: 'curlimages/curl'
@@ -21,5 +19,3 @@ pipeline:
       - 'webhook'
     commands:
       - curl -XPOST --fail -s "$WEBHOOK"
-    when:
-      event: tag

.woodpecker/.lint.yml

@@ -1,4 +1,6 @@
 platform: 'linux/amd64'
+branches:
+  exclude: [main]
 
 pipeline:
   lint:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "site-backend"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 publish = false
 
@@ -11,17 +11,18 @@ name = "site"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-axum = { version = "0.5.1", features = ["http2"] }
-hyper = { version = "0.14.18", features = ["full"] }
-tokio = { version = "1.17.0", features = ["full"] }
-tracing = "0.1.32"
-tracing-subscriber = {version = "0.3.10", features = ["env-filter"] }
-tower-http = { version = "0.2.5", features = ["fs", "trace", "auth"] }
+axum = { version = "0.6.18" }
+hyper = { version = "0.14.26" }
+tokio = { version = "1.28.0", features = ["full"] }
+tracing = "0.1.37"
+tracing-subscriber = {version = "0.3.17", features = ["env-filter"] }
+tower-http = { version = "0.4.0", features = ["fs", "trace", "auth"] }
 tar = "0.4.38"
-flate2 = "1.0.22"
-tokio-util = { version = "0.7.1", features = ["io"] }
-futures-util = "0.3.21"
-uuid = { version = "1.0.0-alpha.1", features = ["v4"] }
-serde_json = "1.0.79"
-metrics = "0.18.1"
-metrics-exporter-prometheus = "0.9.0"
+flate2 = "1.0.26"
+tokio-util = { version = "0.7.8", features = ["io"] }
+futures-util = "0.3.28"
+uuid = { version = "1.3.2", features = ["v4"] }
+serde_json = "1.0.96"
+metrics = "0.21.0"
+metrics-exporter-prometheus = "0.12.0"
+serde = { version = "1.0", features = ["derive"] }

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.59-alpine3.15 AS builder
+FROM rust:1.69-alpine3.16 AS builder
 
 ARG DI_VER=1.2.5
 
@@ -18,7 +18,7 @@ COPY . ./
 RUN cargo build --release
 
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/target/release/site /bin/site
 COPY --from=builder /app/dumb-init /bin/dumb-init

curl

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+
+curl \
+    -XPOST \
+    -T default.tar.gz \
+    -H 'Authorization: Bearer test' \
+    -v \
+    http://localhost:3000/api/deploy

rustfmt.toml

@@ -1,68 +0,0 @@
-unstable_features = true
-binop_separator = "Front"
-blank_lines_lower_bound = 0
-blank_lines_upper_bound = 1
-# Trying something new
-brace_style = "AlwaysNextLine"
-color = "Auto"
-combine_control_expr = false
-comment_width = 80
-condense_wildcard_suffixes = false
-control_brace_style = "AlwaysSameLine"
-disable_all_formatting = false
-edition = "2018"
-emit_mode = "Files"
-empty_item_single_line = true
-enum_discrim_align_threshold = 0
-error_on_line_overflow = false
-error_on_unformatted = false
-fn_args_layout = "Tall"
-fn_single_line = false
-force_explicit_abi = true
-force_multiline_blocks = false
-format_code_in_doc_comments = false
-format_macro_bodies = true
-format_macro_matchers = false
-format_strings = false
-group_imports = "StdExternalCrate"
-hard_tabs = false
-hide_parse_errors = false
-ignore = []
-imports_granularity = "Crate"
-imports_indent = "Block"
-imports_layout = "Mixed"
-indent_style = "Block"
-inline_attribute_width = 0
-license_template_path = ""
-make_backup = false
-match_arm_blocks = true
-match_arm_leading_pipes = "Never"
-match_block_trailing_comma = true
-max_width = 100
-merge_derives = true
-newline_style = "Auto"
-normalize_comments = false
-normalize_doc_attributes = false
-overflow_delimited_expr = false
-remove_nested_parens = true
-reorder_impl_items = false
-reorder_imports = true
-reorder_modules = true
-report_fixme = "Always"
-report_todo = "Always"
-skip_children = false
-space_after_colon = true
-space_before_colon = false
-spaces_around_ranges = false
-struct_field_align_threshold = 0
-struct_lit_single_line = true
-tab_spaces = 4
-trailing_comma = "Vertical"
-trailing_semicolon = true
-type_punctuation_density = "Wide"
-use_field_init_shorthand = false
-use_small_heuristics = "Default"
-use_try_shorthand = false
-version = "One"
-where_single_line = false
-wrap_comments = false

src/api/deploy.rs

@@ -1,96 +1,98 @@
 use std::{collections::HashSet, io::ErrorKind, path::Path};
 
 use axum::{
-    extract::{BodyStream, Extension},
+    extract::{BodyStream, Extension, Query},
     http::StatusCode,
     response::IntoResponse,
 };
 use flate2::read::GzDecoder;
 use futures_util::TryStreamExt;
+use serde::Deserialize;
+use std::io;
 use tar::Archive;
 use tokio_util::io::StreamReader;
 
-use crate::STATIC_DIR_NAME;
+use crate::{DEFAULT_STATIC_SITE, STATIC_DIR_NAME};
+
+#[derive(Deserialize)]
+pub struct StaticDirParams {
+    dir: Option<String>,
+}
 
 pub async fn post_deploy(
     Extension(data_dir): Extension<String>,
+    Query(params): Query<StaticDirParams>,
     res: BodyStream,
-) -> impl IntoResponse
-{
+) -> crate::Result<()> {
     // This converts a stream into something that implements AsyncRead, which we can then use to
     // asynchronously write the file to disk
     let mut read =
         StreamReader::new(res.map_err(|axum_err| std::io::Error::new(ErrorKind::Other, axum_err)));
     let uuid = uuid::Uuid::new_v4();
     let file_path = Path::new(&data_dir).join(uuid.as_hyphenated().to_string());
-    let mut file = tokio::fs::File::create(&file_path).await.unwrap();
-    tokio::io::copy(&mut read, &mut file).await;
+    let mut file = tokio::fs::File::create(&file_path).await?;
+    tokio::io::copy(&mut read, &mut file).await?;
 
+    // If no dir is provided, we use the default one. Otherwise, use the provided one.
+    let static_path = Path::new(&data_dir)
+        .join(STATIC_DIR_NAME)
+        .join(params.dir.unwrap_or(DEFAULT_STATIC_SITE.to_string()));
+
+    // Make sure the static directory exists
+    tokio::fs::create_dir_all(&static_path).await?;
+
+    let fp_clone = file_path.clone();
     // Extract the contents of the tarball synchronously
-    match tokio::task::spawn_blocking(move || {
-        let file = match std::fs::File::open(file_path) {
-            Ok(v) => v,
-            Err(_) => return StatusCode::INTERNAL_SERVER_ERROR,
-        };
-        let tar = GzDecoder::new(file);
-        let mut archive = Archive::new(tar);
+    tokio::task::spawn_blocking(move || process_archive(&fp_clone, &static_path)).await??;
 
-        let mut paths = HashSet::new();
+    // Remove archive file after use
+    tokio::fs::remove_file(&file_path).await?;
 
-        let entries = match archive.entries() {
-            Ok(e) => e,
-            Err(_) => return StatusCode::INTERNAL_SERVER_ERROR,
-        };
-
-        // Extract each entry into the output directory
-        let static_dir = Path::new(&data_dir).join(STATIC_DIR_NAME);
-        for entry_res in entries {
-            if let Ok(mut entry) = entry_res {
-                if let Err(_) = entry.unpack_in(&static_dir) {
-                    return StatusCode::INTERNAL_SERVER_ERROR;
-                }
-
-                if let Ok(path) = entry.path() {
-                    paths.insert(path.into_owned());
-                }
-            } else {
-                return StatusCode::INTERNAL_SERVER_ERROR;
-            }
-        }
-
-        // Remove any old files that weren't present in new archive
-        let mut items = vec![];
-
-        // Start by populating the vec with the initial files
-        let iter = match static_dir.read_dir() {
-            Ok(v) => v,
-            Err(_) => return StatusCode::INTERNAL_SERVER_ERROR,
-        };
-        iter.filter_map(|r| r.ok())
-            .for_each(|e| items.push(e.path()));
-
-        // As long as there are still items in the vec, we keep going
-        while items.len() > 0 {
-            let item = items.pop().unwrap();
-            tracing::debug!("{:?}", item);
-
-            if !paths.contains(item.strip_prefix(&static_dir).unwrap()) {
-                if item.is_dir() {
-                    std::fs::remove_dir_all(item);
-                } else {
-                    std::fs::remove_file(item);
-                }
-            } else if let Ok(iter) = item.read_dir() {
-                iter.filter_map(|r| r.ok())
-                    .for_each(|e| items.push(e.path()));
-            }
-        }
-
-        StatusCode::OK
-    })
-    .await
-    {
-        Ok(s) => s,
-        Err(_) => StatusCode::INTERNAL_SERVER_ERROR,
-    }
+    Ok(())
+}
+
+fn process_archive(archive_path: &Path, static_dir: &Path) -> io::Result<()> {
+    let file = std::fs::File::open(archive_path)?;
+    let tar = GzDecoder::new(file);
+    let mut archive = Archive::new(tar);
+
+    let mut paths = HashSet::new();
+
+    let entries = archive.entries()?;
+    // Extract each entry into the output directory
+    for entry in entries {
+        let mut entry = entry?;
+        entry.unpack_in(static_dir)?;
+
+        if let Ok(path) = entry.path() {
+            paths.insert(path.into_owned());
+        }
+    }
+
+    // Remove any old files that weren't present in new archive
+    let mut items = vec![];
+
+    // Start by populating the vec with the initial files
+    let iter = static_dir.read_dir()?;
+    iter.filter_map(|r| r.ok())
+        .for_each(|e| items.push(e.path()));
+
+    // As long as there are still items in the vec, we keep going
+    while !items.is_empty() {
+        let item = items.pop().unwrap();
+        tracing::debug!("{:?}", item);
+
+        if !paths.contains(item.strip_prefix(&static_dir).unwrap()) {
+            if item.is_dir() {
+                std::fs::remove_dir_all(item)?;
+            } else {
+                std::fs::remove_file(item)?;
+            }
+        } else if let Ok(iter) = item.read_dir() {
+            iter.filter_map(|r| r.ok())
+                .for_each(|e| items.push(e.path()));
+        }
+    }
+
+    Ok(())
 }

src/api/mod.rs

@@ -2,7 +2,6 @@ use axum::{routing::post, Router};
 
 mod deploy;
 
-pub fn router() -> Router
-{
+pub fn router() -> Router {
     Router::new().route("/deploy", post(deploy::post_deploy))
 }

src/error.rs

@@ -0,0 +1,51 @@
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Response};
+use std::error::Error;
+use std::fmt;
+use std::io;
+
+pub type Result<T> = std::result::Result<T, ServerError>;
+
+#[derive(Debug)]
+pub enum ServerError {
+    IO(io::Error),
+    Axum(axum::Error),
+}
+
+impl fmt::Display for ServerError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ServerError::IO(err) => write!(fmt, "{}", err),
+            ServerError::Axum(err) => write!(fmt, "{}", err),
+        }
+    }
+}
+
+impl Error for ServerError {}
+
+impl IntoResponse for ServerError {
+    fn into_response(self) -> Response {
+        match self {
+            ServerError::IO(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+            ServerError::Axum(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+        }
+    }
+}
+
+impl From<io::Error> for ServerError {
+    fn from(err: io::Error) -> Self {
+        ServerError::IO(err)
+    }
+}
+
+impl From<axum::Error> for ServerError {
+    fn from(err: axum::Error) -> Self {
+        ServerError::Axum(err)
+    }
+}
+
+impl From<tokio::task::JoinError> for ServerError {
+    fn from(err: tokio::task::JoinError) -> Self {
+        ServerError::IO(err.into())
+    }
+}

src/main.rs

@@ -1,24 +1,31 @@
+mod api;
+mod error;
+mod matrix;
+mod metrics;
+
+pub use error::Result;
+
 use std::{future::ready, net::SocketAddr};
 
 use axum::{
     extract::Extension,
-    http::StatusCode,
     middleware,
-    routing::{get, get_service},
+    response::Redirect,
+    routing::{any, get},
     Router,
 };
-use tower_http::{auth::RequireAuthorizationLayer, services::ServeDir, trace::TraceLayer};
+use tower_http::{
+    services::ServeDir, trace::TraceLayer, validate_request::ValidateRequestHeaderLayer,
+};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
-mod api;
-mod matrix;
-mod metrics;
-
+/// Name of the directory where static sites are stored inside the data directory
 const STATIC_DIR_NAME: &str = "static";
+/// Name of the subdir of STATIC_DIR_NAME where the default (fallback) site is located
+const DEFAULT_STATIC_SITE: &str = "default";
 
 #[tokio::main]
-async fn main()
-{
+async fn main() {
     // Enable tracing
     tracing_subscriber::registry()
         .with(tracing_subscriber::EnvFilter::new(
@@ -34,26 +41,53 @@ async fn main()
 
     std::fs::create_dir_all(&static_dir);
 
+    // Initialize metrics
     let recorder_handle = metrics::setup_metrics_recorder();
 
-    let app = Router::new()
+    let mut app = Router::new()
         // Handle Matrix .well-known files
         .nest("/", matrix::router())
         // Routes under /api path
         .nest(
             "/api",
-            api::router().layer(RequireAuthorizationLayer::bearer(&api_key)),
+            api::router().layer(ValidateRequestHeaderLayer::bearer(&api_key)),
         )
-        .route("/metrics", get(move || ready(recorder_handle.render())))
+        .route("/metrics", get(move || ready(recorder_handle.render())));
+
+    // Each static site gets mounted explicitely so that the default site can be used as fallback
+    // Each entry is of the form (route, static dir name)
+    let sites = [
+        ("/docs/vieter", "docs-vieter"),
+        ("/api-docs/vieter", "api-docs-vieter"),
+        ("/man/vieter", "man-vieter"),
+    ];
+
+    for (path, dir) in sites {
+        let full_path = format!("{}/{}", static_dir, dir);
+
+        app = app.nest_service(path, ServeDir::new(full_path));
+    }
+
+    // Define some redirects
+    let redirects = [
+        ("/github", "https://github.com/ChewingBever"),
+        ("/gitea", "https://git.rustybever.be/Chewing_Bever"),
+        ("/gitlab", "https://gitlab.com/Chewing_Bever"),
+        ("/codeberg", "https://codeberg.org/Chewing_Bever"),
+        ("/matrix", "https://matrix.to/#/@jef:rustybever.be"),
+        ("/aur", "https://aur.archlinux.org/account/Chewing_Bever"),
+    ];
+
+    for (path, url) in redirects {
+        app = app.route(path, any(|| async { Redirect::permanent(url) }))
+    }
+
+    app = app
         // The fallback option is to serve the actual static files
-        .fallback(get_service(ServeDir::new(static_dir)).handle_error(
-            |error: std::io::Error| async move {
-                (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    format!("Unhandled internal error: {}", error),
-                )
-            },
-        ))
+        .fallback_service(ServeDir::new(format!(
+            "{}/{}",
+            static_dir, DEFAULT_STATIC_SITE
+        )))
         .layer(middleware::from_fn(metrics::track_metrics))
         .layer(Extension(data_dir))
         .layer(TraceLayer::new_for_http());

src/matrix.rs

@@ -1,19 +1,16 @@
 use axum::{response::IntoResponse, routing::get, Json, Router};
 use serde_json::json;
 
-pub fn router() -> Router
-{
+pub fn router() -> Router {
     Router::new()
         .route("/.well-known/matrix/server", get(get_matrix_server))
         .route("/.well-known/matrix/client", get(get_matrix_client))
 }
 
-async fn get_matrix_server() -> impl IntoResponse
-{
+async fn get_matrix_server() -> impl IntoResponse {
     Json(json!({"m.server": "matrix.rustybever.be:443"}))
 }
 
-async fn get_matrix_client() -> impl IntoResponse
-{
+async fn get_matrix_client() -> impl IntoResponse {
     Json(json!({"m.homeserver": {"base_url": "https://matrix.rustybever.be"}}))
 }

src/metrics.rs

@@ -3,8 +3,7 @@ use std::time::Instant;
 use axum::{extract::MatchedPath, http::Request, middleware::Next, response::IntoResponse};
 use metrics_exporter_prometheus::{Matcher, PrometheusBuilder, PrometheusHandle};
 
-pub fn setup_metrics_recorder() -> PrometheusHandle
-{
+pub fn setup_metrics_recorder() -> PrometheusHandle {
     const EXPONENTIAL_SECONDS: &[f64] = &[
         0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0,
     ];
@@ -20,8 +19,7 @@ pub fn setup_metrics_recorder() -> PrometheusHandle
 }
 
 // Taken from the examples section
-pub async fn track_metrics<B>(req: Request<B>, next: Next<B>) -> impl IntoResponse
-{
+pub async fn track_metrics<B>(req: Request<B>, next: Next<B>) -> impl IntoResponse {
     let start = Instant::now();
     let path = if let Some(matched_path) = req.extensions().get::<MatchedPath>() {
         matched_path.as_str().to_owned()