Enabled HTTP/2 in axum; bumped version

Reviewed-on: #2

.woodpecker/.deploy.yml

@@ -1,5 +1,5 @@
-platform: linux/amd64
-branch: main
+platform: 'linux/amd64'
+branches: 'main'
 
 pipeline:
   release:

.woodpecker/.lint.yml

@@ -0,0 +1,7 @@
+platform: 'linux/amd64'
+
+pipeline:
+  lint:
+    image: 'rustlang/rust:nightly'
+    commands:
+      - cargo fmt -- --check

Cargo.lock

@@ -857,9 +857,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.9"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e0ab7bdc962035a87fba73f3acca9b8a8d0034c2e6f60b84aeaaddddc155dce"
+checksum = "b9df98b037d039d03400d9dd06b0f8ce05486b5f25e9a2d7d36196e142ebbc52"
 dependencies = [
  "ansi_term",
  "lazy_static",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "site-backend"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
 publish = false
 
@@ -11,11 +11,11 @@ name = "site"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-axum = { version = "0.5.0" }
+axum = { version = "0.5.0", 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.9", features = ["env-filter"] }
+tracing-subscriber = {version = "0.3.10", features = ["env-filter"] }
 tower-http = { version = "0.2.5", features = ["fs", "trace", "auth"] }
 tar = "0.4.38"
 flate2 = "1.0.22"

renovate.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
+}

rustfmt.toml

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,96 @@
+use std::{collections::HashSet, io::ErrorKind, path::Path};
+
+use axum::{
+    extract::{BodyStream, Extension},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use flate2::read::GzDecoder;
+use futures_util::TryStreamExt;
+use tar::Archive;
+use tokio_util::io::StreamReader;
+
+use crate::STATIC_DIR_NAME;
+
+pub async fn post_deploy(
+    Extension(data_dir): Extension<String>,
+    res: BodyStream,
+) -> impl IntoResponse
+{
+    // 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;
+
+    // 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);
+
+        let mut paths = HashSet::new();
+
+        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,
+    }
+}

src/api/mod.rs

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

src/main.rs

@@ -1,31 +1,21 @@
-use axum::{
-    extract::{BodyStream, Extension},
-    http::StatusCode,
-    response::{IntoResponse, Json},
-    routing::{get, get_service, post},
-    Router,
-};
-use flate2::read::GzDecoder;
-use futures_util::TryStreamExt;
-use serde_json::{json, Value};
-use std::collections::HashSet;
-use std::io::ErrorKind;
 use std::net::SocketAddr;
-use std::path::Path;
-use tar::Archive;
-use tokio_util::io::StreamReader;
+
+use axum::{extract::Extension, http::StatusCode, routing::get_service, Router};
 use tower_http::{auth::RequireAuthorizationLayer, services::ServeDir, trace::TraceLayer};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
+mod api;
+mod matrix;
+
 const STATIC_DIR_NAME: &str = "static";
 
 #[tokio::main]
-async fn main() {
+async fn main()
+{
     // Enable tracing
     tracing_subscriber::registry()
         .with(tracing_subscriber::EnvFilter::new(
-            std::env::var("RUST_LOG")
-                .unwrap_or_else(|_| "site_backend=debug,tower_http=debug".into()),
+            std::env::var("RUST_LOG").unwrap_or_else(|_| "site=debug,tower_http=debug".into()),
         ))
         .with(tracing_subscriber::fmt::layer())
         .init();
@@ -38,11 +28,12 @@ async fn main() {
     std::fs::create_dir_all(&static_dir);
 
     let app = Router::new()
-        .route("/.well-known/matrix/server", get(get_matrix_server))
-        .route("/.well-known/matrix/client", get(get_matrix_client))
-        .route(
-            "/api/deploy",
-            post(post_deploy).layer(RequireAuthorizationLayer::bearer(&api_key)),
+        // Handle Matrix .well-known files
+        .nest("/", matrix::router())
+        // Routes under /api path
+        .nest(
+            "/api",
+            api::router().layer(RequireAuthorizationLayer::bearer(&api_key)),
         )
         // The fallback option is to serve the actual static files
         .fallback(get_service(ServeDir::new(static_dir)).handle_error(
@@ -63,90 +54,3 @@ async fn main() {
         .await
         .unwrap();
 }
-
-async fn get_matrix_server() -> impl IntoResponse {
-    Json(json!({"m.server": "matrix.rustybever.be:443"}))
-}
-
-async fn get_matrix_client() -> impl IntoResponse {
-    Json(json!({"m.homeserver": {"base_url": "https://matrix.rustybever.be"}}))
-}
-
-async fn post_deploy(Extension(data_dir): Extension<String>, res: BodyStream) -> impl IntoResponse {
-    // 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;
-
-    // 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);
-
-        let mut paths = HashSet::new();
-
-        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,
-    }
-}

src/matrix.rs

@@ -0,0 +1,19 @@
+use axum::{response::IntoResponse, routing::get, Json, Router};
+use serde_json::json;
+
+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
+{
+    Json(json!({"m.server": "matrix.rustybever.be:443"}))
+}
+
+async fn get_matrix_client() -> impl IntoResponse
+{
+    Json(json!({"m.homeserver": {"base_url": "https://matrix.rustybever.be"}}))
+}