my-lsp4j/src/main/java/dev/snowdrop/lsp/common/utils/LanguageServer.java at f6e5d57251b2f2bf398610623aa3c60ed644ef28 · ch007m/my-lsp4j · GitHub

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
package dev.snowdrop.lsp.common.utils;

import dev.snowdrop.lsp.proxy.JavaLanguageServer;
import org.eclipse.lsp4j.InitializeParams;
import org.eclipse.lsp4j.InitializeResult;
import org.eclipse.lsp4j.InitializedParams;
import org.eclipse.lsp4j.jsonrpc.Launcher;
import org.eclipse.lsp4j.launch.LSPLauncher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.nio.file.Path;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Utility class for setting up LSP server and client communication in tests and demos.
 * Eliminates code duplication between test classes and main launcher classes.
 */
public class LanguageServer {
    private static final Logger logger = LoggerFactory.getLogger(LanguageServer.class);

    /**
     * Create and set up an LSP server and client using piped streams.
     *
     * @return LSPConnection
     * @throws Exception if setup fails
     */
    public static LSPConnection launchServerAndClient() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        try {
            // Create piped streams for client-server communication
            PipedInputStream serverIn = new PipedInputStream();
            PipedOutputStream clientOut = new PipedOutputStream(serverIn);

            PipedInputStream clientIn = new PipedInputStream();
            PipedOutputStream serverOut = new PipedOutputStream(clientIn);

            // Create and start server
            JavaLanguageServer server = new JavaLanguageServer();
            Launcher<org.eclipse.lsp4j.services.LanguageServer> serverLauncher = new LSPLauncher.Builder<org.eclipse.lsp4j.services.LanguageServer>()
                .setLocalService(server)
                .setRemoteInterface(org.eclipse.lsp4j.services.LanguageServer.class)
                .setInput(serverIn)
                .setOutput(serverOut)
                .setExecutorService(executor)
                .create();

            serverLauncher.startListening();

            // Create client
            LspClient client = new LspClient();
            Launcher<org.eclipse.lsp4j.services.LanguageServer> clientLauncher = new LSPLauncher.Builder<org.eclipse.lsp4j.services.LanguageServer>()
                .setLocalService(client)
                .setRemoteInterface(org.eclipse.lsp4j.services.LanguageServer.class)
                .setInput(clientIn)
                .setOutput(clientOut)
                .setExecutorService(executor)
                .create();

            org.eclipse.lsp4j.services.LanguageServer serverProxy = clientLauncher.getRemoteProxy();
            clientLauncher.startListening();

            // Allow time for connection establishment
            Thread.sleep(100);

            logger.info("LSP communication setup completed");

            return new LSPConnection(executor, serverLauncher, clientLauncher, serverProxy, server, client);

        } catch (Exception e) {
            // Cleanup on failure
            if (executor != null && !executor.isShutdown()) {
                executor.shutdown();
            }
            throw e;
        }
    }

    /**
     * Initialize the language server with basic parameters.
     *
     * @param serverProxy the server proxy to initialize
     * @param projectRoot the project root directory
     * @return the initialization result
     * @throws Exception if initialization fails
     */
    public static InitializeResult initializeLanguageServer(org.eclipse.lsp4j.services.LanguageServer serverProxy, Path projectRoot) throws Exception {
        InitializeParams initParams = new InitializeParams();
        initParams.setProcessId((int) ProcessHandle.current().pid());
        initParams.setRootUri(projectRoot.toUri().toString());

        CompletableFuture<InitializeResult> initResult = serverProxy.initialize(initParams);
        InitializeResult result = initResult.get(5, TimeUnit.SECONDS);

        // Complete the handshake
        serverProxy.initialized(new InitializedParams());

        logger.info("Language server initialized successfully");
        return result;
    }
}