Replace RpcHandler with a function.

src/network.rs

@@ -343,7 +343,7 @@ mod tests {
         },
         make_aborting_rpc, make_echo_rpc,
     };
-    use crate::{ReplyMessage, RequestMessage, Result, RpcHandler};
+    use crate::{ReplyMessage, RequestMessage, Result};
 
     use super::*;
 
@@ -473,30 +473,20 @@ mod tests {
         Ok(())
     }
 
-    pub struct BlockingRpcHandler {
-        start_barrier: Arc<Barrier>,
-        end_barrier: Arc<Barrier>,
-    }
-
-    impl RpcHandler for BlockingRpcHandler {
-        fn call(&self, data: RequestMessage) -> ReplyMessage {
-            self.start_barrier.wait();
-            self.end_barrier.wait();
-            data.into()
-        }
-    }
-
     #[test]
     fn test_server_killed() -> Result<()> {
         let start_barrier = Arc::new(Barrier::new(2));
         let end_barrier = Arc::new(Barrier::new(2));
         let network = Network::run_daemon();
         let mut server = Server::make_server(TEST_SERVER);
+        let start_barrier_clone = start_barrier.clone();
+        let end_barrier_clone = end_barrier.clone();
         server.register_rpc_handler(
             "blocking".to_owned(),
-            Box::new(BlockingRpcHandler {
-                start_barrier: start_barrier.clone(),
-                end_barrier: end_barrier.clone(),
+            Box::new(move |args| {
+                start_barrier_clone.wait();
+                end_barrier_clone.wait();
+                args.into()
             }),
         )?;
 

src/server.rs

@@ -5,13 +5,10 @@ use parking_lot::Mutex;
 
 use crate::{ReplyMessage, RequestMessage, Result, ServerIdentifier};
 
-pub trait RpcHandler {
-    // Note this method is not async.
-    fn call(&self, data: RequestMessage) -> ReplyMessage;
-}
+pub type RpcHandler = dyn Fn(RequestMessage) -> ReplyMessage;
 
 struct ServerState {
-    rpc_handlers: std::collections::HashMap<String, Arc<Box<dyn RpcHandler>>>,
+    rpc_handlers: std::collections::HashMap<String, Arc<RpcHandler>>,
     rpc_count: std::cell::Cell<usize>,
 }
 
@@ -45,7 +42,7 @@ impl Server {
                 state.rpc_handlers.get(&service_method).cloned()
             };
             let response = match rpc_handler {
-                Some(rpc_handler) => Ok(rpc_handler.call(data)),
+                Some(rpc_handler) => Ok(rpc_handler(data)),
                 None => Err(std::io::Error::new(
                     std::io::ErrorKind::InvalidInput,
                     format!(
@@ -71,7 +68,7 @@ impl Server {
     pub fn register_rpc_handler(
         &mut self,
         service_method: String,
-        rpc_handler: Box<dyn RpcHandler>,
+        rpc_handler: Box<RpcHandler>,
     ) -> Result<()> {
         let mut state = self.state.lock();
         let debug_service_method = service_method.clone();
@@ -115,7 +112,7 @@ impl Server {
 #[cfg(test)]
 mod tests {
     use crate::test_utils::junk_server::{
-        make_test_server, EchoRpcHandler,
+        make_test_server,
         JunkRpcs::{Aborting, Echo},
     };
 
@@ -143,7 +140,7 @@ mod tests {
 
         let result = server.register_rpc_handler(
             "echo".to_string(),
-            Box::new(EchoRpcHandler {}),
+            Box::new(move |_| ReplyMessage::new()),
         );
 
         assert!(result.is_err());

src/test_utils/junk_server.rs

@@ -1,4 +1,4 @@
-use crate::{server::RpcHandler, ReplyMessage, RequestMessage, Server};
+use crate::Server;
 
 pub const TEST_SERVER: &str = &"test-server";
 pub const NON_SERVER: &str = &"non-server";
@@ -23,36 +23,22 @@ impl JunkRpcs {
     }
 }
 
-pub struct EchoRpcHandler {}
-
-impl RpcHandler for EchoRpcHandler {
-    fn call(&self, request: RequestMessage) -> ReplyMessage {
-        let mut reply = bytes::BytesMut::from(request.as_ref());
-        reply.reverse();
-        reply.freeze()
-    }
-}
-
-pub struct AbortingRpcHandler {}
-
-impl RpcHandler for AbortingRpcHandler {
-    fn call(&self, _data: RequestMessage) -> ReplyMessage {
-        panic!("Aborting rpc...")
-    }
-}
-
 pub fn make_test_server() -> Server {
     let mut server = Server::make_server(TEST_SERVER);
     server
         .register_rpc_handler(
             JunkRpcs::Echo.name(),
-            Box::new(EchoRpcHandler {}),
+            Box::new(move |request| {
+                let mut reply = bytes::BytesMut::from(request.as_ref());
+                reply.reverse();
+                reply.freeze()
+            }),
         )
         .expect("Registering the first RPC handler should not fail");
     server
         .register_rpc_handler(
             JunkRpcs::Aborting.name(),
-            Box::new(AbortingRpcHandler {}),
+            Box::new(move |_| panic!("Aborting rpc...")),
         )
         .expect("Registering the second RPC handler should not fail");
     server