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)
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}