Upgrade hyperlane

frameworks/Rust/hyperlane/Cargo.toml

@@ -18,8 +18,7 @@ exclude = [
 ]
 
 [dependencies]
-hyperlane = "4.84.0"
-num_cpus = "1.16.0"
+hyperlane = "4.86.0"
 rand = "0.9.0"
 serde = "1.0.219"
 sqlx = { version = "0.8.3", features = ["runtime-tokio", "postgres"] }

frameworks/Rust/hyperlane/src/const.rs

@@ -0,0 +1,17 @@
+pub const RESPONSEDATA_STR: &str = "Hello, World!";
+pub const RESPONSEDATA_BIN: &[u8] = b"Hello, World!";
+pub const DATABASE_TYPE: &str = "postgres";
+pub const DATABASE_HOST: &str = "tfb-database";
+pub const DATABASE_USER_NAME: &str = "benchmarkdbuser";
+pub const DATABASE_USER_PASSWORD: &str = "benchmarkdbpass";
+pub const DATABASE_PORT: usize = 5_432;
+pub const DATABASE_NAME: &str = "hello_world";
+pub const TABLE_NAME_WORLD: &str = "World";
+pub const TABLE_NAME_FORTUNE: &str = "Fortune";
+pub const ROW_LIMIT: i32 = 500;
+pub const RANDOM_MAX: i32 = 10_000;
+pub const RANDOM_MAX_ADD_ONE: u32 = 10_001;
+pub const KEY_ID: &str = "id";
+pub const KEY_RANDOM_NUMBER: &str = "randomnumber";
+pub const KEY_MESSAGE: &str = "message";
+pub const DB_MAX_CONNECTIONS: u32 = 100;

frameworks/Rust/hyperlane/src/db.rs

@@ -100,9 +100,9 @@ pub async fn connection_db() -> DbPoolConnection {
             DATABASE_NAME
         ),
     };
-    let pool_size: u32 = num_cpus::get() as u32;
+    let pool_size: u32 = (get_thread_count() as u32).min(DB_MAX_CONNECTIONS);
     let pool: DbPoolConnection = PgPoolOptions::new()
-        .max_connections(100)
+        .max_connections(DB_MAX_CONNECTIONS)
         .min_connections(pool_size)
         .max_lifetime(None)
         .test_before_acquire(false)

frameworks/Rust/hyperlane/src/main.rs

@@ -1,14 +1,13 @@
-pub(crate) mod constant;
+pub(crate) mod r#const;
 pub(crate) mod db;
 pub(crate) mod lazy;
 pub(crate) mod request_middleware;
-pub(crate) mod response_middleware;
 pub(crate) mod route;
 pub(crate) mod server;
 pub(crate) mod r#type;
 pub(crate) mod utils;
 
-pub(crate) use constant::*;
+pub(crate) use r#const::*;
 pub(crate) use db::*;
 pub(crate) use hyperlane::{
     futures::{executor::block_on, future::join_all},
@@ -21,7 +20,6 @@ pub(crate) use hyperlane::{
 pub(crate) use lazy::*;
 pub(crate) use rand::{Rng, SeedableRng, rng, rngs::SmallRng};
 pub(crate) use request_middleware::*;
-pub(crate) use response_middleware::*;
 pub(crate) use route::*;
 pub(crate) use server::*;
 pub(crate) use sqlx::{

frameworks/Rust/hyperlane/src/request_middleware.rs

@@ -9,7 +9,5 @@ pub async fn request(ctx: Context) {
         .set_response_header(SERVER, HYPERLANE)
         .await
         .set_response_header(DATE, gmt())
-        .await
-        .set_response_status_code(200)
         .await;
 }

frameworks/Rust/hyperlane/src/route.rs

@@ -5,23 +5,23 @@ pub async fn json(ctx: Context) {
         "message": RESPONSEDATA_STR
     });
     let _ = ctx
-        .set_response_body(serde_json::to_string(&json).unwrap_or_default())
+        .send_response(200, serde_json::to_string(&json).unwrap_or_default())
         .await;
 }
 
 pub async fn plaintext(ctx: Context) {
     let _ = ctx
         .set_response_header(CONTENT_TYPE, TEXT_PLAIN)
         .await
-        .set_response_body(RESPONSEDATA_BIN)
+        .send_response(200, RESPONSEDATA_BIN)
         .await;
 }
 
 pub async fn db(ctx: Context) {
     let db_connection: &DbPoolConnection = get_db_connection();
     let query_row: QueryRow = random_world_row(db_connection).await;
     let _ = ctx
-        .set_response_body(serde_json::to_string(&query_row).unwrap_or_default())
+        .send_response(200, serde_json::to_string(&query_row).unwrap_or_default())
         .await;
 }
 
@@ -36,7 +36,7 @@ pub async fn queries(ctx: Context) {
     let db_pool: &DbPoolConnection = get_db_connection();
     let data: Vec<QueryRow> = get_some_row_id(queries, db_pool).await;
     let _ = ctx
-        .set_response_body(serde_json::to_string(&data).unwrap_or_default())
+        .send_response(200, serde_json::to_string(&data).unwrap_or_default())
         .await;
 }
 
@@ -56,9 +56,10 @@ pub async fn fortunes(ctx: Context) {
     ));
     fortunes_list.sort_by(|it, next| it.message.cmp(&next.message));
     let res: String = FortunesTemplate::new(fortunes_list).to_string();
-    ctx.set_response_header(CONTENT_TYPE, content_type_charset(TEXT_HTML, UTF8))
+    let _ = ctx
+        .set_response_header(CONTENT_TYPE, content_type_charset(TEXT_HTML, UTF8))
         .await
-        .set_response_body(res)
+        .send_response(200, res)
         .await;
 }
 
@@ -72,7 +73,7 @@ pub async fn updates(ctx: Context) {
         .max(1);
     let res: Vec<QueryRow> = update_world_rows(queries).await;
     let _ = ctx
-        .set_response_body(serde_json::to_string(&res).unwrap_or_default())
+        .send_response(200, serde_json::to_string(&res).unwrap_or_default())
         .await;
 }
 
@@ -86,6 +87,6 @@ pub async fn cached_queries(ctx: Context) {
         .max(1);
     let res: Vec<QueryRow> = CACHE.iter().take(count as usize).cloned().collect();
     let _ = ctx
-        .set_response_body(serde_json::to_string(&res).unwrap_or_default())
+        .send_response(200, serde_json::to_string(&res).unwrap_or_default())
         .await;
 }