bitwarden_ipc/rpc/exec/
handler.rs

1use std::future::Future;
2
3use erased_serde::Serialize as ErasedSerialize;
4
5use crate::{
6    rpc::{error::RpcError, request::RpcRequest, request_message::RpcRequestPayload},
7    serde_utils,
8};
9
10/// Trait defining a handler for RPC requests.
11/// These can registered with the IPC client and will be used to handle incoming RPC requests.
12pub trait RpcHandler {
13    /// The request type that this handler can process.
14    type Request: RpcRequest;
15
16    /// Handle the request. Any errors that occur should be defined as part of the `RpcRequest`
17    /// type.
18    fn handle(
19        &self,
20        request: Self::Request,
21    ) -> impl Future<Output = <Self::Request as RpcRequest>::Response> + Send;
22}
23
24pub(crate) trait RpcHandlerExt {
25    type Request: RpcRequest;
26
27    fn serialize_request(&self, request: Self::Request) -> Result<Vec<u8>, RpcError>;
28
29    fn deserialize_request(&self, request: Vec<u8>) -> Result<Self::Request, RpcError>;
30
31    fn serialize_response(
32        &self,
33        request: <Self::Request as RpcRequest>::Response,
34    ) -> Result<Vec<u8>, RpcError>;
35
36    fn deserialize_response(
37        &self,
38        request: Vec<u8>,
39    ) -> Result<<Self::Request as RpcRequest>::Response, RpcError>;
40}
41
42impl<T: RpcHandler> RpcHandlerExt for T
43where
44    T: RpcHandler,
45{
46    type Request = T::Request;
47
48    fn serialize_request(&self, request: Self::Request) -> Result<Vec<u8>, RpcError> {
49        serde_utils::to_vec(&request)
50            .map_err(|e| RpcError::RequestSerializationError(e.to_string()))
51    }
52
53    fn deserialize_request(&self, request: Vec<u8>) -> Result<Self::Request, RpcError> {
54        serde_utils::from_slice(&request)
55            .map_err(|e| RpcError::RequestDeserializationError(e.to_string()))
56    }
57
58    fn serialize_response(
59        &self,
60        request: <Self::Request as RpcRequest>::Response,
61    ) -> Result<Vec<u8>, RpcError> {
62        serde_utils::to_vec(&request)
63            .map_err(|e| RpcError::ResponseSerializationError(e.to_string()))
64    }
65
66    fn deserialize_response(
67        &self,
68        request: Vec<u8>,
69    ) -> Result<<Self::Request as RpcRequest>::Response, RpcError> {
70        serde_utils::from_slice(&request)
71            .map_err(|e| RpcError::ResponseDeserializationError(e.to_string()))
72    }
73}
74
75#[async_trait::async_trait]
76pub(crate) trait ErasedRpcHandler: Send + Sync {
77    async fn handle(
78        &self,
79        serialized_request: &RpcRequestPayload,
80    ) -> Result<Box<dyn ErasedSerialize>, RpcError>;
81}
82
83#[async_trait::async_trait]
84impl<H> ErasedRpcHandler for H
85where
86    H: RpcHandler + Send + Sync,
87{
88    async fn handle(
89        &self,
90        serialized_request: &RpcRequestPayload,
91    ) -> Result<Box<dyn ErasedSerialize>, RpcError> {
92        let request: H::Request = serialized_request.deserialize_full()?.request;
93
94        let response = self.handle(request).await;
95
96        Ok(Box::new(response) as Box<dyn ErasedSerialize>)
97    }
98}