@eclipse-glsp/server 2.8.0-next.7 → 2.8.0

package/src/node/launch/socket-server-launcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Disposable } from '@eclipse-glsp/protocol';
+import { Disposable, Emitter } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc/node';
@@ -24,48 +24,71 @@ import { Logger } from '../../common/utils/logger';
 export class SocketServerLauncher extends JsonRpcGLSPServerLauncher<net.TcpSocketConnectOpts> {
     @inject(Logger) protected override logger: Logger;
 
-    protected netServer: net.Server;
+    protected netServer?: net.Server;
 
-    constructor() {
-        super();
+    protected onConnectionEmitter = new Emitter<net.Socket>();
+
+    /**
+     * Fires for every socket the server accepts, before the JSON-RPC connection is built on it.
+     *
+     * A listener must not consume the socket. Subscribe before {@link start} to observe the first connection; the
+     * subscription outlives an individual launch and is disposed by the caller.
+     */
+    readonly onConnection = this.onConnectionEmitter.event;
+
+    protected override getServerSocket(): net.Server | undefined {
+        return this.netServer;
+    }
+
+    protected override registerDisposables(): void {
+        super.registerDisposables();
         this.toDispose.push(
             Disposable.create(() => {
-                this.netServer.close();
+                this.netServer?.close();
             })
         );
     }
 
     protected run(opts: net.TcpSocketConnectOpts): Promise<void> {
-        this.netServer = net.createServer(socket => {
-            const connection = this.createConnection(socket);
-            this.createServerInstance(connection);
-        });
+        this.resetListening();
+        const netServer = net.createServer(socket => this.acceptConnection(socket));
+        this.netServer = netServer;
 
-        this.netServer.listen(opts.port, opts.host);
-        this.netServer.on('listening', () => {
-            const addressInfo = this.netServer.address();
-            if (!addressInfo) {
-                this.logger.error('Could not resolve GLSP Server address info. Shutting down.');
-                this.shutdown();
-                return;
-            } else if (typeof addressInfo === 'string') {
-                this.logger.error(`GLSP Server is unexpectedly listening to pipe or domain socket "${addressInfo}". Shutting down.`);
-                this.shutdown();
-                return;
-            }
-            const currentPort = addressInfo.port;
-            this.logger.info(`The GLSP server is ready to accept new client requests on port: ${currentPort}`);
-            // Print a message to the output stream that indicates that the start is completed.
-            // This indicates to the client that the server process is ready (in an embedded scenario).
-            console.log(this.startupCompleteMessage.concat(currentPort.toString()));
-        });
-        this.netServer.on('error', () => this.shutdown());
+        netServer.listen(opts.port, opts.host);
+        netServer.on('listening', () => this.handleListening(netServer));
+        netServer.on('error', error => this.handleError(error));
         return new Promise((resolve, reject) => {
-            this.netServer.on('close', () => resolve(undefined));
-            this.netServer.on('error', error => reject(error));
+            netServer.on('close', () => resolve(undefined));
+            netServer.on('error', error => reject(error));
         });
     }
 
+    /**
+     * Takes up a socket the server accepted. Observers are notified before the socket is read from.
+     *
+     * @param socket The accepted socket.
+     */
+    protected acceptConnection(socket: net.Socket): void {
+        this.onConnectionEmitter.fire(socket);
+        this.createServerInstance(this.createConnection(socket));
+    }
+
+    /**
+     * Reports the server as ready and resolves {@link listening}.
+     *
+     * @param server The server that reported itself as listening.
+     */
+    protected handleListening(server: net.Server): void {
+        const addressInfo = this.settleListening(server);
+        if (!addressInfo) {
+            return;
+        }
+        this.logger.info(`The GLSP server is ready to accept new client requests on port: ${addressInfo.port}`);
+        // Print a message to the output stream that indicates that the start is completed.
+        // This indicates to the client that the server process is ready (in an embedded scenario).
+        console.log(this.startupCompleteMessage.concat(addressInfo.port.toString()));
+    }
+
     protected createConnection(socket: net.Socket): jsonrpc.MessageConnection {
         return jsonrpc.createMessageConnection(new jsonrpc.SocketMessageReader(socket), new jsonrpc.SocketMessageWriter(socket), console);
     }

package/src/node/launch/websocket-server-launcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -14,12 +14,12 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { createWebSocketConnection, Disposable, MaybePromise, WebSocketWrapper } from '@eclipse-glsp/protocol';
+import { createWebSocketConnection, Disposable, Emitter, MaybePromise, WebSocketWrapper } from '@eclipse-glsp/protocol';
 import * as http from 'http';
 import { inject, injectable } from 'inversify';
 import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc';
-import { Server, WebSocket } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
 import { JsonRpcGLSPServerLauncher } from '../../common/launch/jsonrpc-server-launcher';
 import { Logger } from '../../common/utils/logger';
 
@@ -41,6 +41,13 @@ export interface WebsocketConnectionData {
     connection: jsonrpc.MessageConnection;
 }
 
+/** An accepted web socket together with the upgrade request it was negotiated with. */
+export interface AcceptedWebSocket {
+    socket: WebSocket;
+    /** The handshake request, the only place where its headers and query are still available. */
+    request: http.IncomingMessage;
+}
+
 const STATUS_UPGRADE_REQUIRED = 426;
 
 @injectable()
@@ -48,35 +55,86 @@ export class WebSocketServerLauncher extends JsonRpcGLSPServerLauncher<WebSocket
     @inject(Logger)
     protected override logger: Logger;
 
-    protected server: Server;
+    protected server?: WebSocketServer;
+
+    /**
+     * The HTTP server the web socket server is mounted on.
+     *
+     * Held separately because `ws` only closes an HTTP server it created itself, so releasing the socket is up to us.
+     */
+    protected httpServer?: http.Server;
 
-    constructor() {
-        super();
+    protected onConnectionEmitter = new Emitter<AcceptedWebSocket>();
+
+    /**
+     * Fires for every web socket the server accepts, before the JSON-RPC connection is built on it.
+     *
+     * A listener must not consume the socket. Subscribe before {@link start} to observe the first connection; the
+     * subscription outlives an individual launch and is disposed by the caller.
+     */
+    readonly onConnection = this.onConnectionEmitter.event;
+
+    protected override getServerSocket(): net.Server | undefined {
+        return this.httpServer;
+    }
+
+    protected override registerDisposables(): void {
+        super.registerDisposables();
         this.toDispose.push(
             Disposable.create(() => {
-                this.server.close();
+                this.server?.close();
+                // `ws` leaves an HTTP server it did not create itself listening, so close ours explicitly.
+                this.httpServer?.close();
+                this.httpServer = undefined;
             })
         );
     }
 
     protected async run(options: WebSocketServerOptions): Promise<void> {
+        this.resetListening();
         const resolvedOptions = await this.resolveOptions(options);
-        this.server = new Server({ server: resolvedOptions.server, path: resolvedOptions.path });
+        if (!this.running) {
+            // Shut down while the options were being resolved, so release the socket they already bound.
+            resolvedOptions.server.close();
+            return;
+        }
+        this.httpServer = resolvedOptions.server;
+        this.server = new WebSocketServer({ server: resolvedOptions.server, path: resolvedOptions.path });
         const endpoint = `ws://${resolvedOptions.host}:${resolvedOptions.port}:${resolvedOptions.path}`;
         this.logger.info(`The GLSP Websocket launcher is ready to accept new client requests on endpoint '${endpoint}'`);
         console.log(this.startupCompleteMessage.concat(resolvedOptions.port.toString()));
 
-        this.server.on('connection', (ws, req) => {
-            const connection = this.createConnection(ws);
-            this.createServerInstance(connection);
-        });
+        this.observeListening(resolvedOptions.server);
+        this.server.on('connection', (ws, request) => this.acceptConnection(ws, request));
 
+        const server = this.server;
         return new Promise((resolve, reject) => {
-            this.server.on('close', () => resolve(undefined));
-            this.server.on('error', error => reject(error));
+            server.on('close', () => resolve(undefined));
+            server.on('error', error => reject(error));
         });
     }
 
+    /** Settles {@link listening} from the HTTP server, which may already be bound by the time we get here. */
+    protected observeListening(server: http.Server): void {
+        if (server.listening) {
+            this.settleListening(server);
+            return;
+        }
+        server.on('listening', () => this.settleListening(server));
+        server.on('error', error => this.handleError(error));
+    }
+
+    /**
+     * Takes up a web socket the server accepted. Observers are notified before the socket is read from.
+     *
+     * @param socket  The accepted web socket.
+     * @param request The upgrade request the socket was negotiated with.
+     */
+    protected acceptConnection(socket: WebSocket, request: http.IncomingMessage): void {
+        this.onConnectionEmitter.fire({ socket, request });
+        this.createServerInstance(this.createConnection(socket));
+    }
+
     protected createConnection(socket: WebSocket): jsonrpc.MessageConnection {
         return createWebSocketConnection(wrapWebSocket(socket));
     }