add delay middleware

benches/bench/main.rs

@@ -229,36 +229,42 @@ fn config() -> Config {
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::ASYNC_FAST_CALL.to_string(),
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::SYNC_MEM_CALL.to_string(),
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::ASYNC_MEM_CALL.to_string(),
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::SYNC_SLOW_CALL.to_string(),
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::ASYNC_SLOW_CALL.to_string(),
                     params: vec![],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
                 RpcMethod {
                     method: helpers::ASYNC_INJECT_CALL.to_string(),
@@ -278,6 +284,7 @@ fn config() -> Config {
                     ],
                     response: None,
                     cache: None,
+                    delay_ms: None,
                 },
             ],
             subscriptions: vec![RpcSubscription {

config.yml

@@ -25,6 +25,7 @@ extensions:
 
 middlewares:
   methods:
+    - delay
     - response
     - inject_params
     - cache

src/config/rpc.rs

@@ -32,6 +32,9 @@ pub struct RpcMethod {
 
     #[serde(default)]
     pub response: Option<JsonValue>,
+
+    #[serde(default)]
+    pub delay_ms: Option<u64>,
 }
 
 #[derive(Copy, Clone, Deserialize, Debug)]

src/middlewares/methods/cache.rs

@@ -350,6 +350,7 @@ mod tests {
                 }),
                 params: vec![],
                 response: None,
+                delay_ms: None,
             },
             &ext,
         )
@@ -366,6 +367,7 @@ mod tests {
                 }),
                 params: vec![],
                 response: None,
+                delay_ms: None,
             },
             &ext,
         )
@@ -382,6 +384,7 @@ mod tests {
                 }),
                 params: vec![],
                 response: None,
+                delay_ms: None,
             },
             &ext,
         )
@@ -395,6 +398,7 @@ mod tests {
                 cache: None,
                 params: vec![],
                 response: None,
+                delay_ms: None,
             },
             &ext,
         )

src/middlewares/methods/delay.rs

@@ -0,0 +1,46 @@
+use std::time::Duration;
+
+use async_trait::async_trait;
+
+use crate::{
+    middleware::{Middleware, MiddlewareBuilder, NextFn, RpcMethod},
+    middlewares::{CallRequest, CallResult},
+    utils::{TypeRegistry, TypeRegistryRef},
+};
+
+pub struct DelayMiddleware {
+    delay: Duration,
+}
+
+impl DelayMiddleware {
+    pub fn new(delay: u64) -> Self {
+        Self {
+            delay: Duration::from_millis(delay),
+        }
+    }
+}
+
+#[async_trait]
+impl MiddlewareBuilder<RpcMethod, CallRequest, CallResult> for DelayMiddleware {
+    async fn build(
+        method: &RpcMethod,
+        _extensions: &TypeRegistryRef,
+    ) -> Option<Box<dyn Middleware<CallRequest, CallResult>>> {
+        method
+            .delay_ms
+            .map(|delay| Box::new(DelayMiddleware::new(delay)) as Box<dyn Middleware<CallRequest, CallResult>>)
+    }
+}
+
+#[async_trait]
+impl Middleware<CallRequest, CallResult> for DelayMiddleware {
+    async fn call(
+        &self,
+        request: CallRequest,
+        context: TypeRegistry,
+        next: NextFn<CallRequest, CallResult>,
+    ) -> CallResult {
+        tokio::time::sleep(self.delay).await;
+        next(request, context).await
+    }
+}

src/middlewares/methods/mod.rs

@@ -1,5 +1,6 @@
 pub mod block_tag;
 pub mod cache;
+pub mod delay;
 pub mod inject_params;
 pub mod response;
 pub mod upstream;

src/middlewares/mod.rs

@@ -43,6 +43,7 @@ pub async fn create_method_middleware(
         "cache" => cache::CacheMiddleware::build(method, extensions).await,
         "block_tag" => block_tag::BlockTagMiddleware::build(method, extensions).await,
         "inject_params" => inject_params::InjectParamsMiddleware::build(method, extensions).await,
+        "delay" => delay::DelayMiddleware::build(method, extensions).await,
         _ => panic!("Unknown method middleware: {}", name),
     }
 }

src/server.rs

@@ -201,6 +201,7 @@ mod tests {
                     params: vec![],
                     cache: None,
                     response: None,
+                    delay_ms: None,
                 }],
                 subscriptions: vec![],
                 aliases: vec![],