split rpc calls into 3 Services

Author: hinto-janai

binaries/cuprated/src/rpc/handler.rs

@@ -3,6 +3,11 @@
 //---------------------------------------------------------------------------------------------------- Use
 use std::task::Poll;
 
+use cuprate_rpc_types::{
+    bin::{BinRequest, BinResponse},
+    json::{JsonRpcRequest, JsonRpcResponse},
+    other::{OtherRequest, OtherResponse},
+};
 use futures::channel::oneshot::channel;
 use serde::{Deserialize, Serialize};
 use tower::Service;
@@ -36,32 +41,57 @@ impl RpcHandler for CupratedRpcHandler {
     }
 }
 
-impl Service<RpcRequest> for CupratedRpcHandler {
-    type Response = RpcResponse;
+// INVARIANT:
+//
+// We don't need to check for `self.is_restricted()`
+// here because `cuprate-rpc-interface` handles that.
+//
+// We can assume the request coming has the required permissions.
+
+impl Service<JsonRpcRequest> for CupratedRpcHandler {
+    type Response = JsonRpcResponse;
     type Error = RpcError;
-    type Future = InfallibleOneshotReceiver<Result<RpcResponse, RpcError>>;
+    type Future = InfallibleOneshotReceiver<Result<JsonRpcResponse, RpcError>>;
 
     fn poll_ready(&mut self, _: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
-    /// INVARIANT:
-    ///
-    /// We don't need to check for `self.is_restricted()`
-    /// here because `cuprate-rpc-interface` handles that.
-    ///
-    /// We can assume the request coming has the required permissions.
-    fn call(&mut self, req: RpcRequest) -> Self::Future {
+    fn call(&mut self, request: JsonRpcRequest) -> Self::Future {
         let state = Self::clone(self);
+        let response = json::map_request(state, request).expect("TODO");
+        todo!()
+    }
+}
 
-        let resp = match req {
-            RpcRequest::JsonRpc(r) => {
-                RpcResponse::JsonRpc(json::map_request(state, r).expect("TODO"))
-            } // JSON-RPC 2.0 requests.
-            RpcRequest::Binary(r) => RpcResponse::Binary(bin::map_request(state, r).expect("TODO")), // Binary requests.
-            RpcRequest::Other(r) => RpcResponse::Other(other::map_request(state, r).expect("TODO")), // JSON (but not JSON-RPC) requests.
-        };
+impl Service<BinRequest> for CupratedRpcHandler {
+    type Response = BinResponse;
+    type Error = RpcError;
+    type Future = InfallibleOneshotReceiver<Result<BinResponse, RpcError>>;
 
+    fn poll_ready(&mut self, _: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: BinRequest) -> Self::Future {
+        let state = Self::clone(self);
+        let response = bin::map_request(state, request).expect("TODO");
+        todo!()
+    }
+}
+
+impl Service<OtherRequest> for CupratedRpcHandler {
+    type Response = OtherResponse;
+    type Error = RpcError;
+    type Future = InfallibleOneshotReceiver<Result<OtherResponse, RpcError>>;
+
+    fn poll_ready(&mut self, _: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: OtherRequest) -> Self::Future {
+        let state = Self::clone(self);
+        let response = other::map_request(state, request).expect("TODO");
         todo!()
     }
 }

rpc/interface/src/route/bin.rs

@@ -67,13 +67,8 @@ macro_rules! generate_endpoints_inner {
         paste::paste! {
             {
                 // Send request.
-                let request = RpcRequest::Binary($request);
-                let channel = $handler.oneshot(request).await?;
+                let response = $handler.oneshot($request).await?;
 
-                // Assert the response from the inner handler is correct.
-                let RpcResponse::Binary(response) = channel else {
-                    panic!("RPC handler did not return a binary response");
-                };
                 let BinResponse::$variant(response) = response else {
                     panic!("RPC handler returned incorrect response");
                 };

rpc/interface/src/route/json_rpc.rs

@@ -50,13 +50,7 @@ pub(crate) async fn json_rpc<H: RpcHandler>(
     }
 
     // Send request.
-    let request = RpcRequest::JsonRpc(request.body);
-    let channel = handler.oneshot(request).await?;
-
-    // Assert the response from the inner handler is correct.
-    let RpcResponse::JsonRpc(response) = channel else {
-        panic!("RPC handler returned incorrect response");
-    };
+    let response = handler.oneshot(request.body).await?;
 
     Ok(Json(Response::ok(id, response)))
 }

rpc/interface/src/route/other.rs

@@ -81,13 +81,9 @@ macro_rules! generate_endpoints_inner {
                 }
 
                 // Send request.
-                let request = RpcRequest::Other(OtherRequest::$variant($request));
-                let channel = $handler.oneshot(request).await?;
+                let request = OtherRequest::$variant($request);
+                let response = $handler.oneshot(request).await?;
 
-                // Assert the response from the inner handler is correct.
-                let RpcResponse::Other(response) = channel else {
-                    panic!("RPC handler did not return a binary response");
-                };
                 let OtherResponse::$variant(response) = response else {
                     panic!("RPC handler returned incorrect response")
                 };

rpc/interface/src/rpc_handler.rs

@@ -3,6 +3,11 @@
 //---------------------------------------------------------------------------------------------------- Use
 use std::future::Future;
 
+use cuprate_rpc_types::{
+    bin::{BinRequest, BinResponse},
+    json::{JsonRpcRequest, JsonRpcResponse},
+    other::{OtherRequest, OtherResponse},
+};
 use tower::Service;
 
 use crate::{rpc_error::RpcError, rpc_request::RpcRequest, rpc_response::RpcResponse};
@@ -33,10 +38,22 @@ pub trait RpcHandler:
     + Sync
     + 'static
     + Service<
-        RpcRequest,
-        Response = RpcResponse,
+        JsonRpcRequest,
+        Response = JsonRpcResponse,
         Error = RpcError,
-        Future: Future<Output = Result<RpcResponse, RpcError>> + Send + Sync + 'static,
+        Future: Future<Output = Result<JsonRpcResponse, RpcError>> + Send + Sync + 'static,
+    >
+    + Service<
+        OtherRequest,
+        Response = OtherResponse,
+        Error = RpcError,
+        Future: Future<Output = Result<OtherResponse, RpcError>> + Send + Sync + 'static,
+    >
+    + Service<
+        BinRequest,
+        Response = BinResponse,
+        Error = RpcError,
+        Future: Future<Output = Result<BinResponse, RpcError>> + Send + Sync + 'static,
     >
 {
     /// Is this [`RpcHandler`] restricted?