migrate about-pages & metrics to axum

Author: syphar

src/web/metrics.rs

@@ -1,12 +1,17 @@
-use crate::db::Pool;
-use crate::BuildQueue;
-use crate::Metrics;
+use crate::{db::Pool, utils::spawn_blocking, web::error::AxumResult, BuildQueue, Metrics};
+use anyhow::Context as _;
 use axum::{
-    extract::MatchedPath, http::Request as AxumRequest, middleware::Next, response::IntoResponse,
+    body::Body,
+    extract::{Extension, MatchedPath},
+    http::Request as AxumRequest,
+    http::{
+        header::{CONTENT_LENGTH, CONTENT_TYPE},
+        Response as AxumHttpResponse, StatusCode,
+    },
+    middleware::Next,
+    response::IntoResponse,
 };
-use iron::headers::ContentType;
 use iron::prelude::*;
-use iron::status::Status;
 use prometheus::{Encoder, HistogramVec, TextEncoder};
 use std::{
     borrow::Cow,
@@ -16,20 +21,24 @@ use std::{
 #[cfg(test)]
 use tracing::debug;
 
-pub(super) fn metrics_handler(req: &mut Request) -> IronResult<Response> {
-    let metrics = extension!(req, Metrics);
-    let pool = extension!(req, Pool);
-    let queue = extension!(req, BuildQueue);
+pub(super) async fn metrics_handler(
+    Extension(pool): Extension<Pool>,
+    Extension(metrics): Extension<Arc<Metrics>>,
+    Extension(queue): Extension<Arc<BuildQueue>>,
+) -> AxumResult<impl IntoResponse> {
+    let families = spawn_blocking(move || metrics.gather(&pool, &queue)).await?;
 
     let mut buffer = Vec::new();
-    let families = ctry!(req, metrics.gather(pool, queue));
-    ctry!(req, TextEncoder::new().encode(&families, &mut buffer));
+    TextEncoder::new()
+        .encode(&families, &mut buffer)
+        .context("error encoding metrics")?;
 
-    let mut resp = Response::with(buffer);
-    resp.status = Some(Status::Ok);
-    resp.headers.set(ContentType::plaintext());
-
-    Ok(resp)
+    Ok(AxumHttpResponse::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, mime::TEXT_PLAIN.as_ref())
+        .header(CONTENT_LENGTH, buffer.len())
+        .body(Body::from(buffer))
+        .context("error generating response")?)
 }
 
 /// Converts a `Duration` to seconds, used by prometheus internally

src/web/routes.rs

@@ -61,6 +61,15 @@ pub(super) fn build_axum_routes() -> AxumRouter {
             "/about/builds",
             get_internal(super::sitemap::about_builds_handler),
         )
+        .route(
+            "/about/metrics",
+            get_internal(super::metrics::metrics_handler),
+        )
+        .route("/about", get_internal(super::sitemap::about_handler))
+        .route(
+            "/about/:subpage",
+            get_internal(super::sitemap::about_handler),
+        )
         .route(
             "/releases",
             get_internal(super::releases::recent_releases_handler),
@@ -133,10 +142,6 @@ pub(super) fn build_routes() -> Routes {
 
     routes.internal_page("/", super::releases::home_page);
 
-    routes.internal_page("/about", super::sitemap::about_handler);
-    routes.internal_page("/about/metrics", super::metrics::metrics_handler);
-    routes.internal_page("/about/:subpage", super::sitemap::about_handler);
-
     routes.static_resource("/releases/feed", super::releases::releases_feed_handler);
     routes.internal_page("/releases/:owner", super::releases::owner_handler);
     routes.internal_page("/releases/:owner/:page", super::releases::owner_handler);

src/web/sitemap.rs

@@ -1,19 +1,19 @@
 use crate::{
     db::Pool,
     docbuilder::Limits,
-    impl_axum_webpage, impl_webpage,
+    impl_axum_webpage,
     utils::{get_config, spawn_blocking, ConfigName},
     web::{
         error::{AxumNope, AxumResult},
-        page::WebPage,
+        AxumErrorPage,
     },
 };
 use axum::{
     extract::{Extension, Path},
+    http::StatusCode,
     response::IntoResponse,
 };
 use chrono::{DateTime, TimeZone, Utc};
-use iron::{IronResult, Request as IronRequest, Response as IronResponse};
 use serde::Serialize;
 
 /// sitemap index
@@ -133,32 +133,34 @@ struct AboutPage<'a> {
     active_tab: &'a str,
 }
 
-impl_webpage!(AboutPage<'_> = |this: &AboutPage| this.template.clone().into());
+impl_axum_webpage!(AboutPage<'_> = |this: &AboutPage| this.template.clone().into());
 
-pub fn about_handler(req: &mut IronRequest) -> IronResult<IronResponse> {
-    use super::ErrorPage;
-    use iron::status::Status;
+pub(crate) async fn about_handler(subpage: Option<Path<String>>) -> AxumResult<impl IntoResponse> {
+    let subpage = match subpage {
+        Some(subpage) => subpage.0,
+        None => "index".to_string(),
+    };
 
-    let name = match *req.url.path().last().expect("iron is broken") {
+    let name = match &subpage[..] {
         "about" | "index" => "index",
         x @ "badges" | x @ "metadata" | x @ "redirections" | x @ "download" => x,
         _ => {
             let msg = "This /about page does not exist. \
                 Perhaps you are interested in <a href=\"https://github.com/rust-lang/docs.rs/tree/master/templates/core/about\">creating</a> it?";
-            let page = ErrorPage {
+            let page = AxumErrorPage {
                 title: "The requested page does not exist",
-                message: Some(msg.into()),
-                status: Status::NotFound,
+                message: msg.into(),
+                status: StatusCode::NOT_FOUND,
             };
-            return page.into_response(req);
+            return Ok(page.into_response());
         }
     };
     let template = format!("core/about/{}.html", name);
-    AboutPage {
+    Ok(AboutPage {
         template,
         active_tab: name,
     }
-    .into_response(req)
+    .into_response())
 }
 
 #[cfg(test)]