shuck_server/session/
client.rs

1use std::any::TypeId;
2use std::fmt::Display;
3
4use anyhow::{Context, anyhow};
5use lsp_server::{ErrorCode, Message, Notification, RequestId, ResponseError};
6use serde_json::Value;
7
8use crate::Session;
9use crate::server::{ConnectionSender, Event, MainLoopSender};
10
11pub(crate) type ClientResponseHandler =
12    Box<dyn FnOnce(&Client, &mut Session, lsp_server::Response) + Send>;
13
14/// Handle used by the server to send LSP messages back to the client.
15#[derive(Clone, Debug)]
16pub struct Client {
17    main_loop_sender: MainLoopSender,
18    client_sender: ConnectionSender,
19}
20
21impl Client {
22    /// Create a client handle from main-loop and LSP connection channels.
23    pub fn new(main_loop_sender: MainLoopSender, client_sender: ConnectionSender) -> Self {
24        Self {
25            main_loop_sender,
26            client_sender,
27        }
28    }
29
30    pub(crate) fn send_request<R>(
31        &self,
32        session: &Session,
33        params: R::Params,
34        response_handler: impl FnOnce(&Client, &mut Session, R::Result) + Send + 'static,
35    ) -> crate::Result<()>
36    where
37        R: lsp_types::request::Request,
38    {
39        let response_handler = Box::new(
40            move |client: &Client, session: &mut Session, response: lsp_server::Response| match (
41                response.error,
42                response.result,
43            ) {
44                (Some(err), _) => {
45                    tracing::error!(
46                        "Client request failed (method={} code={}): {}",
47                        R::METHOD,
48                        err.code,
49                        err.message
50                    );
51                }
52                (None, Some(response)) => match serde_json::from_value(response) {
53                    Ok(response) => response_handler(client, session, response),
54                    Err(error) => {
55                        tracing::error!(
56                            "Failed to deserialize client response for {}: {error}",
57                            R::METHOD
58                        );
59                    }
60                },
61                (None, None) => {
62                    if TypeId::of::<R::Result>() == TypeId::of::<()>() {
63                        match serde_json::from_value(Value::Null) {
64                            Ok(response) => response_handler(client, session, response),
65                            Err(error) => {
66                                tracing::error!(
67                                    "Failed to deserialize unit client response for {}: {error}",
68                                    R::METHOD
69                                );
70                            }
71                        }
72                    } else {
73                        tracing::error!(
74                            "Client response missing result and error for {}",
75                            R::METHOD
76                        );
77                    }
78                }
79            },
80        );
81
82        let id = session
83            .request_queue()
84            .outgoing()
85            .register(response_handler);
86        self.client_sender
87            .send(Message::Request(lsp_server::Request {
88                id,
89                method: R::METHOD.to_string(),
90                params: serde_json::to_value(params).context("Failed to serialize params")?,
91            }))
92            .with_context(|| format!("Failed to send request {}", R::METHOD))?;
93        Ok(())
94    }
95
96    pub(crate) fn send_notification<N>(&self, params: N::Params) -> crate::Result<()>
97    where
98        N: lsp_types::notification::Notification,
99    {
100        self.client_sender
101            .send(Message::Notification(Notification::new(
102                N::METHOD.to_string(),
103                params,
104            )))
105            .map_err(|error| anyhow!("Failed to send notification {}: {error}", N::METHOD))
106    }
107
108    pub(crate) fn respond<R>(
109        &self,
110        id: &RequestId,
111        result: crate::server::Result<R>,
112    ) -> crate::Result<()>
113    where
114        R: serde::Serialize,
115    {
116        let response = match result {
117            Ok(value) => lsp_server::Response::new_ok(id.clone(), value),
118            Err(crate::server::Error { code, error }) => {
119                lsp_server::Response::new_err(id.clone(), code as i32, error.to_string())
120            }
121        };
122
123        self.main_loop_sender
124            .send(Event::SendResponse(response))
125            .map_err(|error| anyhow!("Failed to queue response {id}: {error}"))
126    }
127
128    pub(crate) fn respond_err(&self, id: RequestId, error: ResponseError) -> crate::Result<()> {
129        self.main_loop_sender
130            .send(Event::SendResponse(lsp_server::Response {
131                id,
132                result: None,
133                error: Some(error),
134            }))
135            .map_err(|send_error| anyhow!("Failed to queue error response: {send_error}"))
136    }
137
138    pub(crate) fn show_message(
139        &self,
140        message: impl Display,
141        message_type: lsp_types::MessageType,
142    ) -> crate::Result<()> {
143        self.send_notification::<lsp_types::notification::ShowMessage>(
144            lsp_types::ShowMessageParams {
145                typ: message_type,
146                message: message.to_string(),
147            },
148        )
149    }
150
151    pub(crate) fn log_message(
152        &self,
153        message: impl Display,
154        message_type: lsp_types::MessageType,
155    ) -> crate::Result<()> {
156        self.send_notification::<lsp_types::notification::LogMessage>(lsp_types::LogMessageParams {
157            typ: message_type,
158            message: message.to_string(),
159        })
160    }
161
162    pub(crate) fn show_error_message(&self, message: impl Display) {
163        if let Err(err) = self.show_message(message, lsp_types::MessageType::ERROR) {
164            tracing::error!("Failed to send error message to client: {err}");
165        }
166    }
167
168    pub(crate) fn cancel(&self, session: &mut Session, id: RequestId) -> crate::Result<()> {
169        let method_name = session.request_queue_mut().incoming_mut().cancel(&id);
170        if let Some(method_name) = method_name {
171            tracing::debug!("Cancelled request id={id} method={method_name}");
172            self.client_sender
173                .send(Message::Response(lsp_server::Response {
174                    id,
175                    result: None,
176                    error: Some(ResponseError {
177                        code: ErrorCode::RequestCanceled as i32,
178                        message: "request was cancelled by client".to_owned(),
179                        data: None,
180                    }),
181                }))?;
182        }
183        Ok(())
184    }
185}
shuck_server/session/client.rs

shuck_server/session/
client.rs
