bitwarden_ipc/rpc/exec/
handler.rs1use 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
10pub trait RpcHandler {
13 type Request: RpcRequest;
15
16 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).map_err(|e| RpcError::RequestSerialization(e.to_string()))
50 }
51
52 fn deserialize_request(&self, request: Vec<u8>) -> Result<Self::Request, RpcError> {
53 serde_utils::from_slice(&request)
54 .map_err(|e| RpcError::RequestDeserialization(e.to_string()))
55 }
56
57 fn serialize_response(
58 &self,
59 request: <Self::Request as RpcRequest>::Response,
60 ) -> Result<Vec<u8>, RpcError> {
61 serde_utils::to_vec(&request).map_err(|e| RpcError::ResponseSerialization(e.to_string()))
62 }
63
64 fn deserialize_response(
65 &self,
66 request: Vec<u8>,
67 ) -> Result<<Self::Request as RpcRequest>::Response, RpcError> {
68 serde_utils::from_slice(&request)
69 .map_err(|e| RpcError::ResponseDeserialization(e.to_string()))
70 }
71}
72
73#[async_trait::async_trait]
74pub(crate) trait ErasedRpcHandler: Send + Sync {
75 async fn handle(
76 &self,
77 serialized_request: &RpcRequestPayload,
78 ) -> Result<Box<dyn ErasedSerialize>, RpcError>;
79}
80
81#[async_trait::async_trait]
82impl<H> ErasedRpcHandler for H
83where
84 H: RpcHandler + Send + Sync,
85{
86 async fn handle(
87 &self,
88 serialized_request: &RpcRequestPayload,
89 ) -> Result<Box<dyn ErasedSerialize>, RpcError> {
90 let request: H::Request = serialized_request.deserialize_full()?.request;
91
92 let response = self.handle(request).await;
93
94 Ok(Box::new(response) as Box<dyn ErasedSerialize>)
95 }
96}