Improve the axum entry (#8014)

* axum: Upgrade dependencies

* axum: Remove identity cast

* axum: Use state instead of extensions

… and order / group / merge imports consistently.

* axum: Use str::parse instead of invoking FromStr directly

* axum: Use implicit format-args captures

frameworks/Rust/axum/Cargo.lock

@@ -95,7 +95,7 @@ dependencies = [
  "tokio-pg-mapper-derive",
  "tokio-postgres",
  "tower",
- "tower-http",
+ "tower-http 0.4.0",
  "yarte",
 ]
 
@@ -128,7 +128,7 @@ dependencies = [
  "sync_wrapper",
  "tokio",
  "tower",
- "tower-http",
+ "tower-http 0.3.5",
  "tower-layer",
  "tower-service",
 ]
@@ -2308,6 +2308,24 @@ dependencies = [
  "tower-service",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d1d42a9b3f3ec46ba828e8d376aec14592ea199f70a06a548587ecd1c4ab658"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-range-header",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.2"

frameworks/Rust/axum/Cargo.toml

@@ -47,10 +47,9 @@ tokio-pg-mapper = "0.2.0"
 tokio-pg-mapper-derive = "0.2.0"
 tokio-postgres = "0.7.7"
 tower = { version = "0.4.13", features = ["util"] }
-tower-http = { version = "0.3.5", features = ["set-header"] }
+tower-http = { version = "0.4.0", features = ["set-header"] }
 yarte = "0.15.7"
 
-
 [profile.release]
 lto = true
-codegen-units = 1
+codegen-units = 1

frameworks/Rust/axum/src/database_mongo.rs

@@ -1,34 +1,22 @@
-use axum::async_trait;
-use axum::extract::{Extension, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
-use futures_util::stream::FuturesUnordered;
-use futures_util::TryStreamExt;
-use std::io;
-
-use crate::utils::internal_error;
+use std::{convert::Infallible, io};
+
+use axum::{async_trait, extract::FromRequestParts, http::request::Parts};
+use futures_util::{stream::FuturesUnordered, StreamExt, TryStreamExt};
+use mongodb::{bson::doc, Database};
+
 use crate::{Fortune, World};
-use futures_util::StreamExt;
-use mongodb::bson::doc;
-use mongodb::Database;
 
 pub struct DatabaseConnection(pub Database);
 
 #[async_trait]
-impl<S> FromRequestParts<S> for DatabaseConnection
-where
-    S: Send + Sync,
-{
-    type Rejection = (StatusCode, String);
+impl FromRequestParts<Database> for DatabaseConnection {
+    type Rejection = Infallible;
+
     async fn from_request_parts(
-        parts: &mut Parts,
-        state: &S,
+        _parts: &mut Parts,
+        db: &Database,
     ) -> Result<Self, Self::Rejection> {
-        let Extension(db) = Extension::<Database>::from_request_parts(parts, state)
-            .await
-            .map_err(internal_error)?;
-
-        Ok(Self(db))
+        Ok(Self(db.clone()))
     }
 }
 

frameworks/Rust/axum/src/database_mongo_raw.rs

@@ -1,34 +1,25 @@
-use axum::async_trait;
-use axum::extract::{Extension, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
-use futures_util::stream::FuturesUnordered;
-use futures_util::TryStreamExt;
-use std::io;
-
-use crate::utils::internal_error;
+use std::{convert::Infallible, io};
+
+use axum::{async_trait, extract::FromRequestParts, http::request::Parts};
+use futures_util::{stream::FuturesUnordered, TryStreamExt};
+use mongodb::{
+    bson::{doc, RawDocumentBuf},
+    Database,
+};
+
 use crate::World;
-use mongodb::bson::{doc, RawDocumentBuf};
-use mongodb::Database;
 
 pub struct DatabaseConnection(pub Database);
 
 #[async_trait]
-impl<S> FromRequestParts<S> for DatabaseConnection
-where
-    S: Send + Sync,
-{
-    type Rejection = (StatusCode, String);
+impl FromRequestParts<Database> for DatabaseConnection {
+    type Rejection = Infallible;
 
     async fn from_request_parts(
-        parts: &mut Parts,
-        state: &S,
+        _parts: &mut Parts,
+        db: &Database,
     ) -> Result<Self, Self::Rejection> {
-        let Extension(db) = Extension::<Database>::from_request_parts(parts, state)
-            .await
-            .map_err(internal_error)?;
-
-        Ok(Self(db))
+        Ok(Self(db.clone()))
     }
 }
 

frameworks/Rust/axum/src/database_pg.rs

@@ -1,18 +1,14 @@
-use axum::async_trait;
-use axum::extract::{Extension, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
+use std::{collections::HashMap, convert::Infallible, fmt::Write, io, sync::Arc};
+
+use axum::{async_trait, extract::FromRequestParts, http::request::Parts};
 use futures::{
     stream::futures_unordered::FuturesUnordered, FutureExt, StreamExt, TryStreamExt,
 };
 use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
-use std::sync::Arc;
-use std::{collections::HashMap, fmt::Write, io};
 use tokio::pin;
 use tokio_postgres::{connect, types::ToSql, Client, NoTls, Statement};
 
 use crate::models_pg::{Fortune, World};
-use crate::utils::internal_error;
 
 #[derive(Debug)]
 pub enum PgError {
@@ -49,7 +45,7 @@ impl PgConnection {
         // Spawn connection
         tokio::spawn(async move {
             if let Err(error) = conn.await {
-                eprintln!("Connection error: {}", error);
+                eprintln!("Connection error: {error}");
             }
         });
 
@@ -63,14 +59,14 @@ impl PgConnection {
             q.push_str("UPDATE world SET randomnumber = CASE id ");
 
             for _ in 1..=num {
-                let _ = write!(q, "when ${} then ${} ", pl, pl + 1);
+                let _ = write!(q, "when ${pl} then ${} ", pl + 1);
                 pl += 2;
             }
 
             q.push_str("ELSE randomnumber END WHERE id IN (");
 
             for _ in 1..=num {
-                let _ = write!(q, "${},", pl);
+                let _ = write!(q, "${pl},");
                 pl += 1;
             }
 
@@ -191,21 +187,13 @@ impl PgConnection {
 pub struct DatabaseConnection(pub Arc<PgConnection>);
 
 #[async_trait]
-impl<S> FromRequestParts<S> for DatabaseConnection
-where
-    S: Send + Sync,
-{
-    type Rejection = (StatusCode, String);
+impl FromRequestParts<Arc<PgConnection>> for DatabaseConnection {
+    type Rejection = Infallible;
 
     async fn from_request_parts(
-        parts: &mut Parts,
-        state: &S,
+        _parts: &mut Parts,
+        pg_connection: &Arc<PgConnection>,
     ) -> Result<Self, Self::Rejection> {
-        let Extension(pg_connection) =
-            Extension::<Arc<PgConnection>>::from_request_parts(parts, state)
-                .await
-                .map_err(internal_error)?;
-
-        Ok(Self(pg_connection))
+        Ok(Self(pg_connection.clone()))
     }
 }

frameworks/Rust/axum/src/database_pg_pool.rs

@@ -1,15 +1,15 @@
-use axum::async_trait;
-use axum::extract::{Extension, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
-use deadpool_postgres::{Client, Manager, ManagerConfig, RecyclingMethod};
 use std::io;
-use std::str::FromStr;
+
+use axum::{
+    async_trait,
+    extract::FromRequestParts,
+    http::{request::Parts, StatusCode},
+};
+use deadpool_postgres::{Client, Manager, ManagerConfig, RecyclingMethod};
 use tokio_pg_mapper::FromTokioPostgresRow;
 use tokio_postgres::{NoTls, Row, Statement};
 
-use crate::utils::internal_error;
-use crate::{Fortune, World};
+use crate::{utils::internal_error, Fortune, World};
 
 #[derive(Debug)]
 pub enum PgError {
@@ -33,8 +33,8 @@ pub async fn create_pool(
     database_url: String,
     max_pool_size: u32,
 ) -> deadpool_postgres::Pool {
-    let pg_config =
-        tokio_postgres::Config::from_str(&database_url).expect("invalid database url");
+    let pg_config: tokio_postgres::Config =
+        database_url.parse().expect("invalid database url");
 
     let mgr_config = ManagerConfig {
         recycling_method: RecyclingMethod::Fast,
@@ -51,21 +51,13 @@ pub async fn create_pool(
 pub struct DatabaseClient(pub Client);
 
 #[async_trait]
-impl<S> FromRequestParts<S> for DatabaseClient
-where
-    S: Send + Sync,
-{
+impl FromRequestParts<deadpool_postgres::Pool> for DatabaseClient {
     type Rejection = (StatusCode, String);
 
     async fn from_request_parts(
-        parts: &mut Parts,
-        state: &S,
+        _parts: &mut Parts,
+        pool: &deadpool_postgres::Pool,
     ) -> Result<Self, Self::Rejection> {
-        let Extension(pool) =
-            Extension::<deadpool_postgres::Pool>::from_request_parts(parts, state)
-                .await
-                .map_err(internal_error)?;
-
         let conn = pool.get().await.map_err(internal_error)?;
 
         Ok(Self(conn))

frameworks/Rust/axum/src/database_sqlx.rs

@@ -1,14 +1,17 @@
-use axum::async_trait;
-use axum::extract::{Extension, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
 use std::io;
 
-use crate::utils::internal_error;
-use crate::{Fortune, World};
-use sqlx::pool::PoolConnection;
-use sqlx::postgres::{PgArguments, PgPoolOptions};
-use sqlx::{Arguments, PgPool, Postgres};
+use axum::{
+    async_trait,
+    extract::FromRequestParts,
+    http::{request::Parts, StatusCode},
+};
+use sqlx::{
+    pool::PoolConnection,
+    postgres::{PgArguments, PgPoolOptions},
+    Arguments, PgPool, Postgres,
+};
+
+use crate::{utils::internal_error, Fortune, World};
 
 #[derive(Debug)]
 pub enum PgError {
@@ -44,19 +47,13 @@ pub async fn create_pool(
 pub struct DatabaseConnection(pub PoolConnection<Postgres>);
 
 #[async_trait]
-impl<S> FromRequestParts<S> for DatabaseConnection
-where
-    S: Send + Sync,
-{
+impl FromRequestParts<PgPool> for DatabaseConnection {
     type Rejection = (StatusCode, String);
+
     async fn from_request_parts(
-        parts: &mut Parts,
-        state: &S,
+        _parts: &mut Parts,
+        pool: &PgPool,
     ) -> Result<Self, Self::Rejection> {
-        let Extension(pool) = Extension::<PgPool>::from_request_parts(parts, state)
-            .await
-            .map_err(internal_error)?;
-
         let conn = pool.acquire().await.map_err(internal_error)?;
 
         Ok(Self(conn))

frameworks/Rust/axum/src/main.rs

@@ -1,15 +1,16 @@
+use axum::{
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
+    Json, Router,
+};
+use dotenv::dotenv;
+use tower_http::set_header::SetResponseHeaderLayer;
+
 mod models_common;
 mod server;
 
-use models_common::Message;
-
-use axum::http::StatusCode;
-use axum::http::{header, HeaderValue};
-use axum::response::IntoResponse;
-use axum::Json;
-use axum::{routing::get, Router};
-use dotenv::dotenv;
-use tower_http::set_header::SetResponseHeaderLayer;
+use self::models_common::Message;
 
 pub async fn plaintext() -> &'static str {
     "Hello, World!"

frameworks/Rust/axum/src/main_mongo.rs

@@ -1,30 +1,34 @@
-mod database_mongo;
-mod models_common;
-mod models_mongo;
-mod server;
-mod utils;
+use std::time::Duration;
 
-use axum::http::{header, HeaderValue};
 use axum::{
-    extract::Query, http::StatusCode, response::IntoResponse, routing::get, Extension,
+    extract::Query,
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
     Json, Router,
 };
 use dotenv::dotenv;
-use mongodb::options::{ClientOptions, Compressor};
-use mongodb::Client;
+use mongodb::{
+    options::{ClientOptions, Compressor},
+    Client,
+};
 use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
-use std::time::Duration;
 use tower_http::set_header::SetResponseHeaderLayer;
 use yarte::Template;
 
-use crate::database_mongo::{
-    fetch_fortunes, find_world_by_id, find_worlds, update_worlds,
+mod database_mongo;
+mod models_common;
+mod models_mongo;
+mod server;
+mod utils;
+
+use self::{
+    database_mongo::{
+        fetch_fortunes, find_world_by_id, find_worlds, update_worlds, DatabaseConnection,
+    },
+    models_mongo::{Fortune, FortuneInfo, World},
+    utils::{get_environment_variable, parse_params, Params, Utf8Html},
 };
-use crate::utils::get_environment_variable;
-use database_mongo::DatabaseConnection;
-use models_mongo::FortuneInfo;
-use models_mongo::{Fortune, World};
-use utils::{parse_params, Params, Utf8Html};
 
 #[derive(Template)]
 #[template(path = "fortunes.html.hbs")]
@@ -105,7 +109,7 @@ async fn fortunes(DatabaseConnection(db): DatabaseConnection) -> impl IntoRespon
     let fortune_infos: Vec<FortuneInfo> = fortunes
         .iter()
         .map(|f| FortuneInfo {
-            id: f.id as i32,
+            id: f.id,
             message: f.message.clone(),
         })
         .collect();
@@ -171,7 +175,7 @@ async fn serve() {
         .route("/db", get(db))
         .route("/queries", get(queries))
         .route("/updates", get(updates))
-        .layer(Extension(database))
+        .with_state(database)
         .layer(SetResponseHeaderLayer::if_not_present(
             header::SERVER,
             server_header_value,

frameworks/Rust/axum/src/main_mongo_raw.rs

@@ -1,26 +1,33 @@
-mod database_mongo_raw;
-mod models_common;
-mod models_mongo;
-mod server;
-mod utils;
+use std::time::Duration;
 
-use axum::http::{header, HeaderValue};
 use axum::{
-    extract::Query, http::StatusCode, response::IntoResponse, routing::get, Extension,
+    extract::Query,
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
     Json, Router,
 };
 use dotenv::dotenv;
-use mongodb::options::{ClientOptions, Compressor};
-use mongodb::Client;
+use mongodb::{
+    options::{ClientOptions, Compressor},
+    Client,
+};
 use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
-use std::time::Duration;
 use tower_http::set_header::SetResponseHeaderLayer;
 
-use database_mongo_raw::DatabaseConnection;
-use database_mongo_raw::{find_world_by_id, find_worlds, update_worlds};
-use models_mongo::World;
-use utils::get_environment_variable;
-use utils::{parse_params, Params};
+mod database_mongo_raw;
+mod models_common;
+mod models_mongo;
+mod server;
+mod utils;
+
+use self::{
+    database_mongo_raw::{
+        find_world_by_id, find_worlds, update_worlds, DatabaseConnection,
+    },
+    models_mongo::World,
+    utils::{get_environment_variable, parse_params, Params},
+};
 
 async fn db(DatabaseConnection(db): DatabaseConnection) -> impl IntoResponse {
     let mut rng = SmallRng::from_rng(&mut thread_rng()).unwrap();
@@ -140,7 +147,7 @@ async fn serve() {
         .route("/db", get(db))
         .route("/queries", get(queries))
         .route("/updates", get(updates))
-        .layer(Extension(database))
+        .with_state(database)
         .layer(SetResponseHeaderLayer::if_not_present(
             header::SERVER,
             server_header_value,

frameworks/Rust/axum/src/main_pg.rs

@@ -1,23 +1,25 @@
-mod database_pg;
-mod models_common;
-mod models_pg;
-mod server;
-mod utils;
-
-use axum::http::{header, HeaderValue};
 use axum::{
-    extract::Query, http::StatusCode, response::IntoResponse, routing::get, Extension,
+    extract::Query,
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
     Json, Router,
 };
 use dotenv::dotenv;
 use tower_http::set_header::SetResponseHeaderLayer;
 use yarte::Template;
 
-use crate::database_pg::{DatabaseConnection, PgConnection};
-use models_pg::Fortune;
-use utils::{parse_params, Params};
+mod database_pg;
+mod models_common;
+mod models_pg;
+mod server;
+mod utils;
 
-use crate::utils::{get_environment_variable, Utf8Html};
+use self::{
+    database_pg::{DatabaseConnection, PgConnection},
+    models_pg::Fortune,
+    utils::{get_environment_variable, parse_params, Params, Utf8Html},
+};
 
 #[derive(Template)]
 #[template(path = "fortunes.html.hbs")]
@@ -101,7 +103,7 @@ async fn serve() {
         .route("/db", get(db))
         .route("/queries", get(queries))
         .route("/updates", get(updates))
-        .layer(Extension(pg_connection.clone()))
+        .with_state(pg_connection)
         .layer(SetResponseHeaderLayer::if_not_present(
             header::SERVER,
             server_header_value,

frameworks/Rust/axum/src/main_pg_pool.rs

@@ -1,30 +1,31 @@
-mod database_pg_pool;
-mod models_common;
-mod models_pg_pool;
-mod server;
-mod utils;
-
-use crate::database_pg_pool::{
-    create_pool, fetch_all_fortunes, fetch_world_by_id,
-    prepare_fetch_all_fortunes_statement, prepare_fetch_world_by_id_statement,
-    prepare_update_world_by_id_statement, update_world, DatabaseClient, PgError,
-};
-use axum::http::{header, HeaderValue};
 use axum::{
-    extract::Query, http::StatusCode, response::IntoResponse, routing::get, Extension,
+    extract::Query,
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
     Json, Router,
 };
 use dotenv::dotenv;
-use futures_util::stream::FuturesUnordered;
-use futures_util::TryStreamExt;
-use rand::rngs::SmallRng;
-use rand::{thread_rng, Rng, SeedableRng};
+use futures_util::{stream::FuturesUnordered, TryStreamExt};
+use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
 use tower_http::set_header::SetResponseHeaderLayer;
 use yarte::Template;
 
-use crate::utils::{get_environment_variable, Utf8Html};
-use models_pg_pool::{Fortune, World};
-use utils::{parse_params, random_number, Params};
+mod database_pg_pool;
+mod models_common;
+mod models_pg_pool;
+mod server;
+mod utils;
+
+use self::{
+    database_pg_pool::{
+        create_pool, fetch_all_fortunes, fetch_world_by_id,
+        prepare_fetch_all_fortunes_statement, prepare_fetch_world_by_id_statement,
+        prepare_update_world_by_id_statement, update_world, DatabaseClient, PgError,
+    },
+    models_pg_pool::{Fortune, World},
+    utils::{get_environment_variable, parse_params, random_number, Params, Utf8Html},
+};
 
 #[derive(Template)]
 #[template(path = "fortunes.html.hbs")]
@@ -151,7 +152,7 @@ async fn serve() {
         .route("/db", get(db))
         .route("/queries", get(queries))
         .route("/updates", get(updates))
-        .layer(Extension(pool))
+        .with_state(pool)
         .layer(SetResponseHeaderLayer::if_not_present(
             header::SERVER,
             server_header_value,

frameworks/Rust/axum/src/main_sqlx.rs

@@ -1,26 +1,27 @@
-mod database_sqlx;
-mod models_common;
-mod models_sqlx;
-mod server;
-mod utils;
-
-use crate::database_sqlx::{fetch_fortunes, fetch_world, DatabaseConnection};
-use axum::http::{header, HeaderValue};
 use axum::{
-    extract::Extension, http::StatusCode, response::IntoResponse, routing::get, Json,
-    Router,
+    http::{header, HeaderValue, StatusCode},
+    response::IntoResponse,
+    routing::get,
+    Json, Router,
 };
 use dotenv::dotenv;
-use rand::rngs::SmallRng;
-use rand::{thread_rng, Rng, SeedableRng};
+use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
 use sqlx::PgPool;
 use tower_http::set_header::SetResponseHeaderLayer;
 use yarte::Template;
 
-use crate::utils::get_environment_variable;
-use database_sqlx::create_pool;
-use models_sqlx::{Fortune, World};
-use utils::Utf8Html;
+mod database_sqlx;
+mod models_common;
+mod models_sqlx;
+mod server;
+mod utils;
+
+use self::{
+    database_sqlx::{create_pool, fetch_fortunes, fetch_world, DatabaseConnection},
+    models_sqlx::{Fortune, World},
+    utils::get_environment_variable,
+    utils::Utf8Html,
+};
 
 #[derive(Template)]
 #[template(path = "fortunes.html.hbs")]
@@ -86,7 +87,7 @@ async fn router(pool: PgPool) -> Router {
     Router::new()
         .route("/fortunes", get(fortunes))
         .route("/db", get(db))
-        .layer(Extension(pool))
+        .with_state(pool)
         .layer(SetResponseHeaderLayer::if_not_present(
             header::SERVER,
             server_header_value,

frameworks/Rust/axum/src/server.rs

@@ -1,5 +1,7 @@
-use std::io;
-use std::net::{Ipv4Addr, SocketAddr};
+use std::{
+    io,
+    net::{Ipv4Addr, SocketAddr},
+};
 
 use hyper::server::conn::AddrIncoming;
 use tokio::net::{TcpListener, TcpSocket};
@@ -25,7 +27,7 @@ fn reuse_listener(addr: SocketAddr) -> io::Result<TcpListener> {
     #[cfg(unix)]
     {
         if let Err(e) = socket.set_reuseport(true) {
-            eprintln!("error setting SO_REUSEPORT: {}", e);
+            eprintln!("error setting SO_REUSEPORT: {e}");
         }
     }
 

frameworks/Rust/axum/src/utils.rs

@@ -1,22 +1,21 @@
-use axum::body::{Bytes, Full};
-use axum::http::{header, HeaderValue, StatusCode};
-use axum::response::{IntoResponse, Response};
-use rand::rngs::SmallRng;
-use rand::Rng;
-use serde::Deserialize;
+use std::{env, fmt::Debug, str::FromStr};
 
-use std::env;
-use std::fmt::Debug;
-use std::str::FromStr;
+use axum::{
+    body::{Bytes, Full},
+    http::{header, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use rand::{rngs::SmallRng, Rng};
+use serde::Deserialize;
 
 pub fn get_environment_variable<T: FromStr>(key: &str) -> T
 where
     <T as FromStr>::Err: Debug,
 {
-    T::from_str(
-        &env::var(key).unwrap_or_else(|_| panic!("{} environment variable was not set", key)),
-    )
-    .unwrap_or_else(|_| panic!("could not parse {}", key))
+    env::var(key)
+        .unwrap_or_else(|_| panic!("{key} environment variable was not set"))
+        .parse::<T>()
+        .unwrap_or_else(|_| panic!("could not parse {key}"))
 }
 
 #[derive(Debug, Deserialize)]
@@ -40,6 +39,7 @@ pub fn parse_params(params: Params) -> i32 {
 
 /// Utility function for mapping any error into a `500 Internal Server Error`
 /// response.
+#[allow(dead_code)]
 pub fn internal_error<E>(err: E) -> (StatusCode, String)
 where
     E: std::error::Error,