1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//!
//! Module containing an [`Interface`] struct that carries
//! mappings of RPC method and notification handlers.
//!

pub mod method;
pub mod notification;

use crate::imports::*;
pub use method::*;
pub use notification::*;

/// [`Interface`] struct carries a mapping of RPC methods
/// and notifications, used by protocols to dispatch calls
/// to their respective handlers.
pub struct Interface<ServerContext, ConnectionContext, Ops>
where
    ServerContext: Clone + Send + Sync + 'static,
    ConnectionContext: Clone + Send + Sync + 'static,
    Ops: OpsT,
{
    server_ctx: ServerContext,
    methods: AHashMap<Ops, Box<dyn MethodTrait<ServerContext, ConnectionContext>>>,
    notifications: AHashMap<Ops, Box<dyn NotificationTrait<ServerContext, ConnectionContext>>>,
}

impl<ServerContext, ConnectionContext, Ops> Interface<ServerContext, ConnectionContext, Ops>
where
    ServerContext: Clone + Send + Sync + 'static,
    ConnectionContext: Clone + Send + Sync + 'static,
    Ops: OpsT,
{
    /// Create an interface that will contain user-defined
    /// RPC message and notification handlers. This method
    /// accepts `server_ctx` argument that will be subsequently
    /// passed to each RPC method or notification invocation.
    pub fn new(server_ctx: ServerContext) -> Interface<ServerContext, ConnectionContext, Ops> {
        Interface {
            server_ctx,
            methods: AHashMap::new(),
            notifications: AHashMap::new(),
        }
    }

    ///
    /// Declare an RPC method handler. You can use a [`method!()`](macro@crate::server::method)
    /// macro to declare the method as follows:
    ///
    ///
    /// ```rust ignore
    /// interface.method(MyOps::Method, method!(
    ///   | connection_ctx: ConnectionCtx,
    ///     server_ctx: ServerContext,
    ///     req: MyReq |
    /// async move {
    ///     // ...
    ///     Ok(MyResp { })
    /// }))
    /// ```
    ///
    ///
    pub fn method<Req, Resp>(
        &mut self,
        op: Ops,
        method: Method<ServerContext, ConnectionContext, Req, Resp>,
    )
    // -> Self
    where
        Ops: Debug + Clone,
        Req: MsgT,
        Resp: MsgT,
    {
        let method: Box<dyn MethodTrait<ServerContext, ConnectionContext>> = Box::new(method);
        if self.methods.insert(op.clone(), method).is_some() {
            panic!("RPC method {op:?} is declared multiple times")
        }
    }

    ///
    /// Declare an RPC notification handler. You can use a [`notification!()`](macro@crate::server::notification)
    /// macro to declare the notification as follows:
    ///
    ///
    /// ```rust ignore
    /// interface.notification(MyOps::Notify, notification!(
    ///   | connection_ctx: ConnectionCtx,
    ///     server_ctx: ServerContext,
    ///     msg: MyMsg |
    /// async move {
    ///     // ...
    ///     Ok(())
    /// }))
    /// ```
    ///
    ///
    pub fn notification<Msg>(
        &mut self,
        op: Ops,
        method: Notification<ServerContext, ConnectionContext, Msg>,
    ) where
        Ops: Debug + Clone,
        Msg: MsgT,
    {
        let method: Box<dyn NotificationTrait<ServerContext, ConnectionContext>> = Box::new(method);
        if self.notifications.insert(op.clone(), method).is_some() {
            panic!("RPC notification {op:?} is declared multiple times")
        }
    }

    pub(crate) async fn call_method_with_borsh(
        &self,
        op: &Ops,
        connection_ctx: ConnectionContext,
        payload: &[u8],
    ) -> ServerResult<Vec<u8>> {
        if let Some(method) = self.methods.get(op) {
            method
                .call_with_borsh(self.server_ctx.clone(), connection_ctx, payload)
                .await
        } else {
            Err(ServerError::NotFound)
        }
    }

    pub(crate) async fn call_method_with_serde_json(
        &self,
        op: &Ops,
        connection_ctx: ConnectionContext,
        payload: Value,
    ) -> ServerResult<Value> {
        if let Some(method) = self.methods.get(op) {
            method
                .call_with_serde_json(self.server_ctx.clone(), connection_ctx, payload)
                .await
        } else {
            Err(ServerError::NotFound)
        }
    }

    pub(crate) async fn call_notification_with_borsh(
        &self,
        op: &Ops,
        connection_ctx: ConnectionContext,
        payload: &[u8],
    ) -> ServerResult<()> {
        if let Some(notification) = self.notifications.get(op) {
            notification
                .call_with_borsh(self.server_ctx.clone(), connection_ctx, payload)
                .await
        } else {
            Err(ServerError::NotFound)
        }
    }

    pub(crate) async fn call_notification_with_serde_json(
        &self,
        op: &Ops,
        connection_ctx: ConnectionContext,
        payload: Value,
    ) -> ServerResult<()> {
        if let Some(notification) = self.notifications.get(op) {
            notification
                .call_with_serde_json(self.server_ctx.clone(), connection_ctx, payload)
                .await
        } else {
            Err(ServerError::NotFound)
        }
    }
}