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

use std::{fmt::Debug, sync::Arc};

use futures::channel::mpsc::UnboundedSender;
use jsonrpc_core::{MetaIoHandler, Metadata, RpcMethodSimple};
use jsonrpc_pubsub::{PubSubHandler, PubSubMetadata, SubscribeRpcMethod, UnsubscribeRpcMethod};

/// A wrapper around `jsonrpc_core`'s own `Session`, providing some convenience methods and
/// `impl Default::default`.
#[derive(Clone, Debug, Default)]
pub struct Session {
    inner: Option<Arc<jsonrpc_pubsub::Session>>,
}

impl Session {
    /// A mocked session, i.e. created from an mpsc channel that is not wired to anything.
    pub fn mock() -> Session {
        let (sender, _) = futures::channel::mpsc::unbounded();
        let inner = Some(Arc::from(jsonrpc_pubsub::Session::new(sender)));

        Self { inner }
    }
}

impl From<Arc<jsonrpc_pubsub::Session>> for Session {
    fn from(value: Arc<jsonrpc_pubsub::Session>) -> Self {
        Session { inner: Some(value) }
    }
}

impl Metadata for Session {}

impl PubSubMetadata for Session {
    fn session(&self) -> Option<Arc<jsonrpc_pubsub::Session>> {
        self.inner.clone()
    }
}

/// Trait that abstracts away different implementations of IO handlers.
pub trait Handler {
    /// The type to use as the metadata for the IO handler. Especially relevant for PubSub.
    type Metadata: PubSubMetadata + Unpin + Debug;

    /// Add a JSON-RPC method.
    fn add_method<F>(&mut self, name: &str, method: F)
    where
        F: RpcMethodSimple;

    /// Add a JSON-RPC subscription.
    fn add_subscription<F, G>(
        &mut self,
        notification: &str,
        subscribe: (&str, F),
        unsubscribe: (&str, G),
    ) where
        F: SubscribeRpcMethod<Self::Metadata>,
        G: UnsubscribeRpcMethod<Self::Metadata>;

    /// Cast this down to an instance of `MetaIoHandler`.
    fn as_meta_io_handler(&self) -> MetaIoHandler<Self::Metadata>;

    /// Get a list of all the supported JSON-RPC methods.
    fn describe_api(&self) -> Vec<String>;

    /// Programmatically trigger the handling of a JSON-RPC message.
    /// TODO: support async
    fn handle_request_sync(&self, request: &str, meta: Self::Metadata) -> Option<String>;

    /// Derive an instance of the `Self::Metadata` associated type from an `UnboundedSender`.
    fn metadata_from_sender(sender: UnboundedSender<String>) -> Self::Metadata;

    /// Create a new instance of a `Handler` implementation.
    fn new() -> Self;
}

impl<M> Handler for PubSubHandler<M>
where
    M: PubSubMetadata + Unpin + Debug + From<Arc<jsonrpc_pubsub::Session>>,
{
    type Metadata = M;

    fn add_method<F>(&mut self, name: &str, method: F)
    where
        F: RpcMethodSimple,
    {
        MetaIoHandler::add_method(self, name, method)
    }

    fn add_subscription<F, G>(
        &mut self,
        notification: &str,
        subscribe: (&str, F),
        unsubscribe: (&str, G),
    ) where
        F: SubscribeRpcMethod<M>,
        G: UnsubscribeRpcMethod<M>,
    {
        PubSubHandler::add_subscription(self, notification, subscribe, unsubscribe)
    }

    fn as_meta_io_handler(&self) -> MetaIoHandler<Self::Metadata> {
        (*self).clone()
    }

    fn describe_api(&self) -> Vec<String> {
        self.iter().map(|(name, _)| name.clone()).collect()
    }

    fn handle_request_sync(&self, request: &str, meta: Self::Metadata) -> Option<String> {
        MetaIoHandler::handle_request_sync(self, request, meta)
    }

    fn metadata_from_sender(sender: UnboundedSender<String>) -> Self::Metadata {
        Self::Metadata::from(Arc::new(jsonrpc_pubsub::Session::new(sender)))
    }

    fn new() -> Self {
        PubSubHandler::new(jsonrpc_core::MetaIoHandler::default())
    }
}