Upgrade hyperlane

frameworks/Rust/hyperlane/Cargo.toml

@@ -20,8 +20,8 @@ exclude = [
 
 [dependencies]
 futures = "0.3.31"
-hyperlane = "9.5.0"
-hyperlane-time = "0.7.8"
+hyperlane = "10.6.0"
+hyperlane-time = "0.7.12"
 num_cpus = "1.17.0"
 once_cell = "1.21.3"
 rand = "0.9.2"

frameworks/Rust/hyperlane/src/db/fn.rs

@@ -1,19 +1,19 @@
 use super::*;
 
-pub fn get_db_connection() -> &'static DbPoolConnection {
+pub(crate) fn get_db_connection() -> &'static DbPoolConnection {
     &DB
 }
 
 #[cfg(feature = "dev")]
-pub async fn create_database() {
+pub(crate) async fn create_database() {
     let db_pool: &DbPoolConnection = get_db_connection();
     let _ = db_query(&format!("CREATE DATABASE {DATABASE_NAME};"))
         .execute(db_pool)
         .await;
 }
 
 #[cfg(feature = "dev")]
-pub async fn create_table() {
+pub(crate) async fn create_table() {
     let db_pool: &DbPoolConnection = get_db_connection();
     let _ = db_query(&format!(
         "CREATE TABLE IF NOT EXISTS {TABLE_NAME_WORLD} (
@@ -32,7 +32,7 @@ pub async fn create_table() {
 }
 
 #[cfg(feature = "dev")]
-pub async fn insert_records() {
+pub(crate) async fn insert_records() {
     let db_pool: &DbPoolConnection = get_db_connection();
     let row: PgRow = db_query(&format!("SELECT COUNT(*) FROM {TABLE_NAME_WORLD}"))
         .fetch_one(db_pool)
@@ -66,7 +66,7 @@ pub async fn insert_records() {
     let _ = db_query(&sql).execute(db_pool).await;
 }
 
-pub async fn init_cache() -> Vec<QueryRow> {
+pub(crate) async fn init_cache() -> Vec<QueryRow> {
     let mut res: Vec<QueryRow> = Vec::with_capacity(RANDOM_MAX as usize);
     let db_pool: &DbPoolConnection = get_db_connection();
     let sql: String = format!("SELECT id, randomNumber FROM {TABLE_NAME_WORLD} LIMIT {RANDOM_MAX}");
@@ -80,7 +80,7 @@ pub async fn init_cache() -> Vec<QueryRow> {
     res
 }
 
-pub async fn connection_db() -> DbPoolConnection {
+pub(crate) async fn connection_db() -> DbPoolConnection {
     let db_url: &str = match option_env!("POSTGRES_URL") {
         Some(it) => it,
         _ => &format!(
@@ -100,7 +100,7 @@ pub async fn connection_db() -> DbPoolConnection {
     pool
 }
 
-pub async fn get_update_data(limit: Queries) -> (Vec<QueryRow>, Vec<i32>, Vec<i32>) {
+pub(crate) async fn get_update_data(limit: Queries) -> (Vec<QueryRow>, Vec<i32>, Vec<i32>) {
     let db_pool: &DbPoolConnection = get_db_connection();
     let mut query_res_list: Vec<QueryRow> = Vec::with_capacity(limit as usize);
     let rows: Vec<QueryRow> = get_some_row_id(limit, db_pool).await;
@@ -115,32 +115,32 @@ pub async fn get_update_data(limit: Queries) -> (Vec<QueryRow>, Vec<i32>, Vec<i3
     (query_res_list, id_list, random_numbers)
 }
 
-pub async fn init_db() {
+pub(crate) async fn init_db() {
     #[cfg(feature = "dev")]
     {
         create_database().await;
         create_table().await;
         insert_records().await;
     }
     let _ = get_db_connection();
-    let _ = CACHE.get(0);
+    let _ = CACHE.first();
 }
 
-pub async fn random_world_row(db_pool: &DbPoolConnection) -> QueryRow {
+pub(crate) async fn random_world_row(db_pool: &DbPoolConnection) -> QueryRow {
     let random_id: Queries = get_random_id();
     query_world_row(db_pool, random_id).await
 }
 
-pub async fn query_world_row(db_pool: &DbPoolConnection, id: Queries) -> QueryRow {
+pub(crate) async fn query_world_row(db_pool: &DbPoolConnection, id: Queries) -> QueryRow {
     let sql: &str = "SELECT id, randomNumber FROM World WHERE id = $1";
     if let Ok(rows) = db_query(sql).bind(id).fetch_one(db_pool).await {
         let random_number: i32 = rows.get(KEY_RANDOM_NUMBER);
-        return QueryRow::new(id as i32, random_number);
+        return QueryRow::new(id, random_number);
     }
-    return QueryRow::new(id as i32, 1);
+    QueryRow::new(id, 1)
 }
 
-pub async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
+pub(crate) async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
     let db_pool: &DbPoolConnection = get_db_connection();
     let (data, id_list, random_numbers) = get_update_data(limit).await;
     let sql: &str = "UPDATE World SET randomNumber = $1 WHERE id = $2";
@@ -159,14 +159,14 @@ pub async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
     data
 }
 
-pub async fn all_world_row() -> Vec<PgRow> {
+pub(crate) async fn all_world_row() -> Vec<PgRow> {
     let db_pool: &DbPoolConnection = get_db_connection();
     let sql: String = format!("SELECT id, message FROM {TABLE_NAME_FORTUNE}");
     let res: Vec<PgRow> = db_query(&sql).fetch_all(db_pool).await.unwrap_or_default();
-    return res;
+    res
 }
 
-pub async fn get_some_row_id(limit: Queries, db_pool: &DbPoolConnection) -> Vec<QueryRow> {
+pub(crate) async fn get_some_row_id(limit: Queries, db_pool: &DbPoolConnection) -> Vec<QueryRow> {
     let tasks: Vec<_> = (0..limit)
         .map(|_| {
             let db_pool: Pool<Postgres> = db_pool.clone();

frameworks/Rust/hyperlane/src/db/mod.rs

@@ -2,8 +2,8 @@ pub(crate) mod r#fn;
 pub(crate) mod r#static;
 pub(crate) mod r#type;
 
-pub use r#fn::*;
-pub use r#static::*;
-pub use r#type::*;
+pub(crate) use r#fn::*;
+pub(crate) use r#static::*;
+pub(crate) use r#type::*;
 
 use super::*;

frameworks/Rust/hyperlane/src/main.rs

@@ -12,11 +12,7 @@ pub(crate) use std::fmt;
 
 pub(crate) use futures::{executor::block_on, future::join_all};
 pub(crate) use hyperlane::{
-    tokio::{
-        runtime::{Builder, Runtime},
-        spawn,
-        task::JoinHandle,
-    },
+    tokio::{spawn, task::JoinHandle},
     *,
 };
 pub(crate) use hyperlane_time::*;
@@ -30,6 +26,30 @@ pub(crate) use sqlx::{
     query as db_query,
 };
 
-fn main() {
-    run_server();
+use middleware::*;
+use route::*;
+
+#[tokio::main]
+async fn main() {
+    init_db().await;
+
+    let config: ServerConfig = ServerConfig::new().await;
+    config.host("0.0.0.0").await;
+    config.port(8080).await;
+    config.buffer(256).await;
+    config.disable_linger().await;
+    config.disable_nodelay().await;
+
+    let server: Server = Server::from(config).await;
+    server.request_middleware::<RequestMiddleware>().await;
+    server.route::<PlaintextRoute>("/plaintext").await;
+    server.route::<JsonRoute>("/json").await;
+    server.route::<CachedQueryRoute>("/cached-quer").await;
+    server.route::<DbRoute>("/db").await;
+    server.route::<QueryRoute>("/query").await;
+    server.route::<FortunesRoute>("/fortunes").await;
+    server.route::<UpdateRoute>("/upda").await;
+
+    let server_hook: ServerControlHook = server.run().await.unwrap_or_default();
+    server_hook.wait().await;
 }

frameworks/Rust/hyperlane/src/middleware/impl.rs

@@ -0,0 +1,22 @@
+use super::*;
+
+impl ServerHook for RequestMiddleware {
+    async fn new(_ctx: &Context) -> Self {
+        Self
+    }
+
+    async fn handle(self, ctx: &Context) {
+        ctx.set_response_version(HttpVersion::HTTP1_1)
+            .await
+            .set_response_header(CONNECTION, KEEP_ALIVE)
+            .await
+            .set_response_header(SERVER, HYPERLANE)
+            .await
+            .set_response_header(DATE, &gmt())
+            .await
+            .set_response_status_code(200)
+            .await
+            .set_response_header(CONTENT_TYPE, APPLICATION_JSON)
+            .await;
+    }
+}

frameworks/Rust/hyperlane/src/middleware/mod.rs

@@ -1,5 +1,6 @@
-pub(crate) mod r#fn;
+pub(crate) mod r#impl;
+pub(crate) mod r#struct;
 
-pub use r#fn::*;
+pub(crate) use r#struct::*;
 
 use super::*;

frameworks/Rust/hyperlane/src/middleware/struct.rs

@@ -0,0 +1 @@
+pub(crate) struct RequestMiddleware;