Method dispatch_one

plugins/src/lib.rs:913–1038

Dispatch one server-side event and then return. Just so we have a nicer looking `select` statement in `run` :-)

(
        &self,
        input: &mut FramedRead<I, JsonRpcCodec>,
        plugin: &Plugin<S>,
    )

    /// Dispatch one server-side event and then return. Just so we
    /// have a nicer looking `select` statement in `run` :-)
    async fn dispatch_one<I>(
        &self,
        input: &mut FramedRead<I, JsonRpcCodec>,
        plugin: &Plugin<S>,
    ) -> Result<(), Error>
    where
        I: Send + AsyncReadExt + Unpin,
    {
        match input.next().await {
            Some(Ok(msg)) => {
                trace!("Received a message: {:?}", msg);
                match msg {
                    messages::JsonRpc::Request(_id, _p) => {
                        todo!(
                            "This is unreachable until we start filling in messages:Request. Until then the custom dispatcher below is used exclusively."
                        );
                    }
                    messages::JsonRpc::Notification(_n) => {
                        todo!(
                            "As soon as we define the full structure of the messages::Notification we'll get here. Until then the custom dispatcher below is used."
                        )
                    }
                    messages::JsonRpc::CustomRequest(id, request) => {
                        trace!("Dispatching custom method {:?}", request);
                        let method = request
                            .get("method")
                            .context("Missing 'method' in request")?
                            .as_str()
                            .context("'method' is not a string")?;
                        let callback = match method {
                            name if name.eq("setconfig") => {
                                self.setconfig_callback.as_ref().ok_or_else(|| {
                                    anyhow!("No handler for method '{}' registered", method)
                                })?
                            }
                            _ => self.rpcmethods.get(method).with_context(|| {
                                anyhow!("No handler for method '{}' registered", method)
                            })?,
                        };
                        let params = request
                            .get("params")
                            .context("Missing 'params' field in request")?
                            .clone();

                        let plugin = plugin.clone();
                        let call = callback(plugin.clone(), params);

                        tokio::spawn(async move {
                            match call.await {
                                Ok(v) => plugin
                                    .sender
                                    .send(json!({
                                    "jsonrpc": "2.0",
                                    "id": id,
                                    "result": v
                                    }))
                                    .await
                                    .context("returning custom response"),