qlue-ls 2.7.0

A language server for SPARQL
Documentation 
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

use std::rc::Rc;

use futures::lock::Mutex;

use crate::server::{
    Server,
    lsp::{
        AddBackendNotification, GetBackendRequest, GetBackendResponse, ListBackendsRequest,
        ListBackendsResponse, PingBackendRequest, PingBackendResponse,
        UpdateDefaultBackendNotification,
        errors::{ErrorCode, LSPError},
    },
    sparql_operations::check_server_availability,
};

#[tracing::instrument(skip_all, fields(backend = %notification.params.backend_name))]
pub(super) async fn handle_update_backend_default_notification(
    server_rc: Rc<Mutex<Server>>,
    notification: UpdateDefaultBackendNotification,
) -> Result<(), LSPError> {
    tracing::info!("new default backend: {}", notification.params.backend_name);
    // TODO: update default fild in backends state
    let mut server = server_rc.lock().await;
    if server
        .state
        .get_backend(&notification.params.backend_name)
        .is_none()
    {
        return Err(LSPError::new(
            ErrorCode::InvalidParams,
            &format!("Unknown backend \"{}\"", notification.params.backend_name),
        ));
    }
    server
        .state
        .set_default_backend(notification.params.backend_name);
    Ok(())
}

#[tracing::instrument(skip_all, fields(id = %request.get_id()))]
pub(super) async fn handle_ping_backend_request(
    server_rc: Rc<Mutex<Server>>,
    request: PingBackendRequest,
) -> Result<(), LSPError> {
    let backend = {
        let server = server_rc.lock().await;
        match request.params.backend_name {
            Some(ref name) => server.state.get_backend(name).cloned().ok_or(LSPError::new(
                ErrorCode::InvalidParams,
                &format!("got ping request for unknown backend: \"{}\"", name),
            )),
            None => server
                .state
                .get_default_backend()
                .cloned()
                .ok_or(LSPError::new(
                    ErrorCode::InvalidParams,
                    "no backend or default backend provided",
                )),
        }?
    };
    let health_check_url = &backend.health_check_url.as_ref().unwrap_or(&backend.url);
    let available = check_server_availability(health_check_url).await;
    server_rc
        .lock()
        .await
        .send_message(PingBackendResponse::new(request.get_id(), available))
}

#[tracing::instrument(skip_all, fields(backend = %request.params.name))]
pub(super) async fn handle_add_backend_notification(
    server_rc: Rc<Mutex<Server>>,
    request: AddBackendNotification,
) -> Result<(), LSPError> {
    let mut server = server_rc.lock().await;

    server
        .state
        .load_prefix_map(request.params.name.clone(), &request.params.prefix_map)?;
    server.load_templates(&request.params.name, request.params.queries.clone())?;
    let backend_name = request.params.name.clone();
    let default = request.params.default;
    server.state.add_backend(request.params);
    if default {
        server.state.set_default_backend(backend_name);
    }
    Ok(())
}

#[tracing::instrument(skip_all, fields(id = %request.get_id()))]
pub(super) async fn handle_get_backend_request(
    server_rc: Rc<Mutex<Server>>,
    request: GetBackendRequest,
) -> Result<(), LSPError> {
    let server = server_rc.lock().await;
    let (backend, error_message) = match request.params.backend {
        Some(ref name) => (
            server.state.get_backend(name),
            format!("Backend \"{}\" not found.", name),
        ),
        None => (
            server.state.get_default_backend(),
            "No default backend is configured.".to_string(),
        ),
    };
    server.send_message(GetBackendResponse::new(
        request.get_id(),
        backend,
        &error_message,
    ))
}

#[tracing::instrument(skip_all, fields(id = %request.get_id()))]
pub(super) async fn handle_list_backends_request(
    server_rc: Rc<Mutex<Server>>,
    request: ListBackendsRequest,
) -> Result<(), LSPError> {
    let server = server_rc.lock().await;
    server.send_message(ListBackendsResponse::new(
        request.get_id(),
        server.state.get_all_backends(),
    ))
}