Merge pull request #5805 from Turbo87/remove-conduit-router

Remove `conduit-router` and `conduit-middleware` dependencies

Author: Turbo87

Cargo.lock

@@ -35,8 +35,6 @@ clap = { version = "=4.0.32", features = ["derive", "env", "unicode", "wrap_help
 
 conduit = "=0.10.0"
 conduit-axum = { path = "conduit-axum" }
-conduit-middleware = "=0.10.0"
-conduit-router = "=0.10.0"
 
 cookie = { version = "=0.16.1", features = ["secure"] }
 dashmap = { version = "=5.4.0", features = ["raw-api"] }

Cargo.toml

@@ -11,7 +11,6 @@ rust-version = "1.56.0"
 [dependencies]
 axum = "=0.6.1"
 conduit = "=0.10.0"
-conduit-router = "=0.10.0"
 hyper = { version = "=0.14.23", features = ["server", "stream"] }
 http = "=0.2.8"
 percent-encoding = "=2.2.0"
@@ -22,7 +21,6 @@ tokio = { version = "=1.23.0", features = ["fs"] }
 tokio-stream = "=0.1.11"
 
 [dev-dependencies]
-conduit-router = "=0.10.0"
 futures-util = "=0.3.25"
 hyper = { version = "=0.14.23", features = ["client"] }
 tokio = { version = "=1.23.0", features = ["macros", "rt-multi-thread"] }

conduit-axum/Cargo.toml

@@ -1,9 +1,8 @@
 #![deny(clippy::all)]
 
 use axum::routing::get;
-use conduit::{Body, Handler, RequestExt, ResponseResult};
-use conduit_axum::{ConduitAxumHandler, Server};
-use conduit_router::RouteBuilder;
+use conduit::{Body, RequestExt, ResponseResult};
+use conduit_axum::ConduitAxumHandler;
 use http::{header, Response};
 
 use std::io;
@@ -14,28 +13,22 @@ async fn main() {
     tracing_subscriber::fmt::init();
 
     let router = axum::Router::new()
-        .route("/axum/", get(wrap(endpoint)))
-        .route("/axum/panic", get(wrap(panic)))
-        .route("/axum/error", get(wrap(error)));
+        .route("/", get(wrap(endpoint)))
+        .route("/panic", get(wrap(panic)))
+        .route("/error", get(wrap(error)));
 
-    let app = build_conduit_handler();
     let addr = ([127, 0, 0, 1], 12345).into();
 
-    Server::serve(&addr, router, app).await;
+    axum::Server::bind(&addr)
+        .serve(router.into_make_service())
+        .await
+        .unwrap()
 }
 
 pub fn wrap<H>(handler: H) -> ConduitAxumHandler<H> {
     ConduitAxumHandler::wrap(handler)
 }
 
-fn build_conduit_handler() -> impl Handler {
-    let mut router = RouteBuilder::new();
-    router.get("/", endpoint);
-    router.get("/panic", panic);
-    router.get("/error", error);
-    router
-}
-
 fn endpoint(_: &mut dyn RequestExt) -> ResponseResult<http::Error> {
     let body = b"Hello world!";
 

conduit-axum/examples/server.rs

@@ -14,7 +14,6 @@ use axum::extract::{rejection::PathRejection, Extension, FromRequestParts, Path}
 use axum::handler::Handler as AxumHandler;
 use axum::response::IntoResponse;
 use conduit::{Handler, RequestExt};
-use conduit_router::RoutePattern;
 use http::header::CONTENT_LENGTH;
 use http::StatusCode;
 use hyper::{Request, Response};
@@ -88,13 +87,7 @@ where
                 let mut request = ConduitRequest::new(request);
                 handler
                     .call(&mut request)
-                    .map(|mut response| {
-                        if let Some(pattern) = request.mut_extensions().remove::<RoutePattern>() {
-                            response.extensions_mut().insert(pattern);
-                        }
-
-                        conduit_into_axum(response)
-                    })
+                    .map(conduit_into_axum)
                     .unwrap_or_else(|e| server_error_response(&*e))
             })
             .await

conduit-axum/src/fallback.rs

@@ -13,19 +13,22 @@
 //! Typical usage:
 //!
 //! ```no_run
+//! use axum::routing::get;
 //! use conduit::Handler;
-//! use conduit_axum::Server;
+//! use conduit_axum::ConduitAxumHandler;
 //! use tokio::runtime::Runtime;
 //!
 //! #[tokio::main]
 //! async fn main() {
-//!     let router = axum::Router::new();
+//!     let router = axum::Router::new()
+//!         .route("/", get(ConduitAxumHandler::wrap(build_conduit_handler())));
 //!
-//!     let app = build_conduit_handler();
 //!     let addr = ([127, 0, 0, 1], 12345).into();
-//!     let server = Server::serve(&addr, router, app);
 //!
-//!     server.await;
+//!     axum::Server::bind(&addr)
+//!         .serve( router.into_make_service())
+//!         .await
+//!         .unwrap();
 //! }
 //!
 //! fn build_conduit_handler() -> impl Handler {
@@ -48,7 +51,6 @@ mod adaptor;
 mod error;
 mod fallback;
 mod file_stream;
-mod server;
 #[cfg(test)]
 mod tests;
 mod tokio_utils;
@@ -58,7 +60,6 @@ pub use fallback::{
     conduit_into_axum, CauseField, ConduitAxumHandler, ConduitFallback, ErrorField,
     RequestParamsExt,
 };
-pub use server::Server;
 pub use tokio_utils::spawn_blocking;
 
 type AxumResponse = axum::response::Response;

conduit-axum/src/lib.rs

@@ -1,7 +1,6 @@
 use super::prelude::*;
 use crate::util::errors::{forbidden, internal, AppError, AppResult};
 use conduit_axum::RequestParamsExt;
-use conduit_router::RequestParams;
 
 /// The Origin header (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin)
 /// is sent with CORS requests and POST requests, and indicates where the request comes from.
@@ -31,10 +30,7 @@ pub trait RequestParamExt<'a> {
 
 impl<'a> RequestParamExt<'a> for &'a (dyn RequestExt + 'a) {
     fn param(self, key: &str) -> Option<&'a str> {
-        return if let Some(params) = self.axum_params() {
-            params.0.get(key).map(|s| &s[..])
-        } else {
-            self.params().find(key)
-        };
+        self.axum_params()
+            .and_then(|params| params.0.get(key).map(|s| &s[..]))
     }
 }

conduit-axum/src/server.rs

@@ -1,7 +1,6 @@
 mod prelude {
     pub use crate::middleware::log_request::CustomMetadataRequestExt;
     pub use conduit::{box_error, Body, Handler, RequestExt};
-    pub use conduit_middleware::{AfterResult, AroundMiddleware, BeforeResult, Middleware};
     pub use http::{header, Response, StatusCode};
 }
 

src/controllers/util.rs

@@ -2,7 +2,7 @@ use crate::app::AppState;
 use axum::extract::{MatchedPath, State};
 use axum::middleware::Next;
 use axum::response::Response;
-use conduit_router::RoutePattern;
+
 use http::Request;
 use prometheus::IntGauge;
 use std::time::Instant;
@@ -24,11 +24,7 @@ pub async fn update_metrics<B>(
 
     let endpoint = match matched_path {
         Some(ref matched_path) => matched_path.as_str(),
-        None => response
-            .extensions()
-            .get::<RoutePattern>()
-            .map(|route_pattern| route_pattern.pattern())
-            .unwrap_or("<unknown>"),
+        None => "<unknown>",
     };
     metrics
         .response_times

src/middleware.rs

@@ -5,12 +5,11 @@ use axum::routing::{delete, get, post, put};
 use axum::Router;
 use conduit::{Handler, HandlerResult, RequestExt};
 use conduit_axum::{CauseField, ConduitAxumHandler};
-use conduit_router::RoutePattern;
 
 use crate::app::AppState;
 use crate::controllers::*;
-use crate::middleware::app::{add_app_state_extension, RequestApp};
-use crate::util::errors::{not_found, AppError, RouteBlocked};
+use crate::middleware::app::add_app_state_extension;
+use crate::util::errors::{not_found, AppError};
 use crate::util::EndpointResult;
 use crate::Env;
 
@@ -207,22 +206,6 @@ struct C(pub fn(&mut dyn RequestExt) -> EndpointResult);
 
 impl Handler for C {
     fn call(&self, req: &mut dyn RequestExt) -> HandlerResult {
-        if let Some(pattern) = req.extensions().get::<RoutePattern>() {
-            let pattern = pattern.pattern();
-
-            // Configure the Sentry `transaction` field *before* we handle the request,
-            // but *after* the conduit-router has figured out which handler to use.
-            let tx_name = format!("{} {}", req.method(), pattern);
-            sentry::configure_scope(|scope| scope.set_transaction(Some(&tx_name)));
-
-            // Allow blocking individual routes by their pattern through the `BLOCKED_ROUTES`
-            // environment variable. This is not in a middleware because we need access to
-            // `RoutePattern` before executing the response handler.
-            if req.app().config.blocked_routes.contains(pattern) {
-                return Ok(RouteBlocked.response());
-            }
-        }
-
         let C(f) = *self;
         match f(req) {
             Ok(resp) => Ok(resp),