bunp ohkami to v0.20, deps & refactor some (#9247)

frameworks/Rust/ohkami/Cargo.toml

@@ -1,13 +1,24 @@
 [package]
 name    = "ohkami_framework_benchmarks"
-version = "0.19.0"
+version = "0.20.0"
 edition = "2021"
 authors = ["kanarus <[email protected]>"]
 
 [dependencies]
-ohkami       = { version = "=0.19.0", features = ["rt_tokio"] }
-tokio        = { version = "1.38.0" , features = ["full"] }
+ohkami       = { version = "=0.20.0", features = ["rt_tokio"] }
+tokio        = { version = "1.40.0" , features = ["full"] }
 rand         = { version = "0.8.5"  , features = ["small_rng"] }
-sqlx         = { version = "0.7.4"  , features = ["postgres", "macros", "runtime-tokio-native-tls"] }
+sqlx         = { version = "0.8.1"  , features = ["postgres", "macros", "runtime-tokio-native-tls"] }
 yarte        = { version = "0.15.7" }
 futures-util = { version = "0.3.30" }
+
+[profile.release]
+opt-level = 3
+debug = false
+debug-assertions = false
+lto = true
+panic = "abort"
+incremental = false
+codegen-units = 1
+rpath = false
+strip = false

frameworks/Rust/ohkami/ohkami.dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.79-slim-buster
+FROM rust:1.80-slim-bullseye
 WORKDIR /ohkami_framework_benchmarks
 
 ENV DATABASE_URL=postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world

frameworks/Rust/ohkami/src/fangs.rs

@@ -1,5 +1,4 @@
 use ohkami::prelude::*;
-use crate::Postgres;
 
 
 #[derive(Clone)]
@@ -10,41 +9,3 @@ impl FangAction for SetServer {
         res.headers.set().Server("ohkami");
     }
 }
-
-impl Postgres {
-    pub async fn init() -> impl FangAction {
-        #[derive(Clone)]
-        pub struct UsePostgres(Postgres);
-        impl FangAction for UsePostgres {
-            #[inline(always)]
-            async fn fore<'a>(&'a self, req: &'a mut Request) -> Result<(), Response> {
-                Ok(req.memorize(self.0.clone()))
-            }
-        }
-
-        macro_rules! load_env {
-            ($($name:ident as $t:ty)*) => {$(
-                #[allow(non_snake_case)]
-                let $name = ::std::env::var(stringify!($name))
-                    .expect(concat!(
-                        "Failed to load environment variable ",
-                        "`", stringify!($name), "`"
-                    ))
-                    .parse::<$t>()
-                    .unwrap();
-            )*};
-        } load_env! {
-            MAX_CONNECTIONS as u32
-            MIN_CONNECTIONS as u32
-            DATABASE_URL    as String
-        }
-            
-        let pool = sqlx::postgres::PgPoolOptions::new()
-            .max_connections(MAX_CONNECTIONS)
-            .min_connections(MIN_CONNECTIONS)
-            .connect(&DATABASE_URL).await
-            .unwrap();
-            
-        UsePostgres(pool.into())
-    }
-}

frameworks/Rust/ohkami/src/main.rs

@@ -11,12 +11,16 @@ mod templates;
 use templates::FortunesTemplate;
 
 use ohkami::prelude::*;
+use ohkami::format::{JSON, Query};
 use ohkami::Memory;
 
 
 #[tokio::main]
 async fn main() {
-    Ohkami::with((SetServer, Postgres::init().await), (
+    Ohkami::with((
+        SetServer,
+        Memory::new(Postgres::new().await),
+    ), (
         "/json"     .GET(json_serialization),
         "/db"       .GET(single_database_query),
         "/queries"  .GET(multiple_database_query),
@@ -26,40 +30,44 @@ async fn main() {
     )).howl("0.0.0.0:8000").await
 }
 
-async fn json_serialization() -> Message {
-    Message {
+async fn json_serialization() -> JSON<Message> {
+    JSON(Message {
         message: "Hello, World!"
-    }
+    })
 }
 
-async fn single_database_query(p: Memory<'_, Postgres>) -> World {
-    p.select_random_world().await
+async fn single_database_query(p: Memory<'_, Postgres>) -> JSON<World> {
+    let world = p.select_random_world().await;
+    JSON(world)
 }
 
-async fn multiple_database_query(q: WorldsQuery<'_>, p: Memory<'_, Postgres>) -> Vec<World> {
+async fn multiple_database_query(
+    Query(q): Query<WorldsQuery<'_>>,
+    p: Memory<'_, Postgres>
+) -> JSON<Vec<World>> {
     let n = q.parse();
-    p.select_n_random_worlds(n).await
+    let worlds = p.select_n_random_worlds(n).await;
+    JSON(worlds)
 }
 
 async fn fortunes(p: Memory<'_, Postgres>) -> FortunesTemplate {
     let mut fortunes = p.select_all_fortunes().await;
-
     fortunes.push(Fortune {
         id:      0,
         message: String::from("Additional fortune added at request time."),
     });
     fortunes.sort_unstable_by(|a, b| str::cmp(&a.message, &b.message));
-
     FortunesTemplate { fortunes }
 }
 
-async fn database_updates(q: WorldsQuery<'_>, p: Memory<'_, Postgres>) -> Vec<World> {
+async fn database_updates(
+    Query(q): Query<WorldsQuery<'_>>,
+    p: Memory<'_, Postgres>
+) -> JSON<Vec<World>> {
     let n = q.parse();
     let mut worlds = p.select_n_random_worlds(n).await;
-
     p.update_random_ids_of_worlds(&mut worlds).await;
-
-    worlds
+    JSON(worlds)
 }
 
 async fn plaintext() -> &'static str {

frameworks/Rust/ohkami/src/models.rs

@@ -1,8 +1,7 @@
-use ohkami::typed::{Payload, Query};
-use ohkami::builtin::payload::JSON;
+use ohkami::serde::{Serialize, Deserialize};
 
 
-#[Payload(JSON/S)]
+#[derive(Serialize)]
 pub struct Message {
     pub message: &'static str,
 }
@@ -14,14 +13,14 @@ pub struct Fortune {
 }
 
 #[derive(sqlx::FromRow)]
-#[Payload(JSON/S)]
+#[derive(Serialize)]
 pub struct World {
     pub id:           i32,
     #[serde(rename="randomNumber")]
     pub randomnumber: i32,
 }
 
-#[Query]
+#[derive(Deserialize)]
 pub struct WorldsQuery<'q> {
     q: Option<&'q str>,
 }

frameworks/Rust/ohkami/src/postgres.rs

@@ -6,9 +6,32 @@ use crate::models::{World, Fortune};
 #[derive(Clone)]
 pub struct Postgres(sqlx::PgPool);
 
-impl From<sqlx::PgPool> for Postgres {
-    fn from(pgpool: sqlx::PgPool) -> Self {
-        Self(pgpool)
+impl Postgres {
+    pub async fn new() -> Self {
+        macro_rules! load_env {
+            ($($name:ident as $t:ty)*) => {$(
+                #[allow(non_snake_case)]
+                let $name = ::std::env::var(stringify!($name))
+                    .expect(concat!(
+                        "Failed to load environment variable ",
+                        "`", stringify!($name), "`"
+                    ))
+                    .parse::<$t>()
+                    .unwrap();
+            )*};
+        } load_env! {
+            MAX_CONNECTIONS as u32
+            MIN_CONNECTIONS as u32
+            DATABASE_URL    as String
+        }
+        
+        let pool = sqlx::postgres::PgPoolOptions::new()
+            .max_connections(MAX_CONNECTIONS)
+            .min_connections(MIN_CONNECTIONS)
+            .connect(&DATABASE_URL).await
+            .unwrap();
+
+        Self(pool)
     }
 }