@eclipse-glsp/server 1.1.0-RC05 → 1.1.0-RC06

package/src/common/launch/glsp-server-launcher.ts

@@ -13,20 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { MaybePromise } from '@eclipse-glsp/protocol';
+import { Disposable, DisposableCollection, MaybePromise } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable, optional } from 'inversify';
 import { ServerModule } from '../di/server-module';
 import { InjectionContainer } from '../di/service-identifiers';
 import { Logger } from '../utils/logger';
 
-export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed';
-
 @injectable()
-export abstract class GLSPServerLauncher<T = undefined> {
+export abstract class GLSPServerLauncher<T> implements Disposable {
     @inject(Logger) protected logger: Logger;
 
     protected _modules: ContainerModule[] = [];
     protected running: boolean;
+    protected toDispose = new DisposableCollection();
 
     @inject(InjectionContainer) @optional() protected parentContainer?: Container;
 
@@ -40,7 +39,7 @@ export abstract class GLSPServerLauncher<T = undefined> {
         return container;
     }
 
-    start(startParams?: T): MaybePromise<void> {
+    start(startParams: T): MaybePromise<void> {
         if (!this.running) {
             this.running = true;
             return this.run(startParams);
@@ -48,10 +47,11 @@ export abstract class GLSPServerLauncher<T = undefined> {
         this.logger.warn('Could not start launcher. Launcher is already running!');
     }
 
-    protected abstract run(startParams?: T): MaybePromise<void>;
+    protected abstract run(startParams: T): MaybePromise<void>;
 
     shutdown(): MaybePromise<void> {
         if (this.running) {
+            this.logger.info('Shutdown GLSPServerLauncher');
             const result = this.stop();
             this.running = false;
             return result;
@@ -59,7 +59,13 @@ export abstract class GLSPServerLauncher<T = undefined> {
         this.logger.warn('Could not stop launcher. Launcher is not running!');
     }
 
-    protected abstract stop(): MaybePromise<void>;
+    protected stop(): MaybePromise<void> {
+        this.dispose();
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
 
     get modules(): ContainerModule[] {
         if (!this._modules) {

package/src/common/operations/operation-action-handler.ts

@@ -66,13 +66,13 @@ export class OperationActionHandler implements ActionHandler {
     protected async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
         const command = await handler.execute(operation);
         if (command) {
-            this.executeCommand(command);
+            await this.executeCommand(command);
         }
         return this.modelSubmissionHandler.submitModel('operation');
     }
 
-    protected executeCommand(command: Command): void {
-        this.commandStack.execute(command);
+    protected async executeCommand(command: Command): Promise<void> {
+        return this.commandStack.execute(command);
     }
 
     protected submitModel(): MaybePromise<Action[]> {

package/src/common/test/mock-util.ts

@@ -25,11 +25,13 @@ import {
     EdgeTypeHint,
     InitializeClientSessionParameters,
     MaybeArray,
+    MaybePromise,
     Point,
     RequestEditValidationAction,
     ShapeTypeHint,
     ValidationStatus
 } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
 import { Container } from 'inversify';
 import { MessageConnection } from 'vscode-jsonrpc';
 import { ActionDispatcher } from '../actions/action-dispatcher';
@@ -53,6 +55,25 @@ export async function delay(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Consumes a maybe async function and checks for error
+ * @param  method - The function to check
+ * @param  message - Optional message to match with error message
+ */
+export async function expectToThrowAsync(toEvaluate: () => MaybePromise<void>, message?: string): Promise<void> {
+    let err: Error | undefined = undefined;
+    try {
+        await toEvaluate();
+    } catch (error: any) {
+        err = error;
+    }
+    if (message) {
+        expect(err?.message).to.be.equal(message);
+    } else {
+        expect(err).to.be.an('Error');
+    }
+}
+
 export function createClientSession(
     id: string,
     diagramType: string,

package/src/common/utils/layout-util.ts

@@ -27,7 +27,7 @@ import { getOrThrow, GLSPServerError } from './glsp-server-error';
  * @param index  The model index.
  * @returns The changed element.
  */
-export function applyBounds(bounds: ElementAndBounds, index: GModelIndex): GBoundsAware | undefined {
+export function applyElementAndBounds(bounds: ElementAndBounds, index: GModelIndex): GBoundsAware | undefined {
     const element = getOrThrow(index.get(bounds.elementId), 'Model element not found! ID: ' + bounds.elementId);
     if (isGBoundsAware(element)) {
         if (bounds.newPosition !== undefined) {

package/src/node/index.ts

@@ -21,3 +21,4 @@ export * from './gmodel/gmodel-storage';
 export * from './launch/cli-parser';
 export * from './launch/socket-cli-parser';
 export * from './launch/socket-server-launcher';
+export * from './launch/websocket-server-launcher';

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

@@ -16,11 +16,13 @@
 import { Container, inject, injectable } from 'inversify';
 import * as net from 'net';
 import * as jsonrpc from 'vscode-jsonrpc/node';
+import { Disposable } from '..';
 import { GLSPServerLauncher } from '../../common/launch/glsp-server-launcher';
 import { GLSPServer, JsonRpcGLSPServer } from '../../common/protocol/glsp-server';
 import { Logger } from '../../common/utils/logger';
 
-const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
+
 @injectable()
 export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnectOpts> {
     @inject(Logger) protected override logger: Logger;
@@ -29,6 +31,16 @@ export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnec
     protected startupCompleteMessage = START_UP_COMPLETE_MSG;
     protected netServer: net.Server;
 
+    constructor() {
+        super();
+        this.toDispose.push(
+            Disposable.create(() => {
+                this.currentConnections.forEach(connection => connection.dispose());
+                this.netServer.close();
+            })
+        );
+    }
+
     protected run(opts: net.TcpSocketConnectOpts): Promise<void> {
         this.netServer = net.createServer(socket => this.createClientConnection(socket));
 
@@ -81,10 +93,4 @@ export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnec
     protected createConnection(socket: net.Socket): jsonrpc.MessageConnection {
         return jsonrpc.createMessageConnection(new jsonrpc.SocketMessageReader(socket), new jsonrpc.SocketMessageWriter(socket), console);
     }
-
-    protected stop(): void {
-        this.logger.info('Shutdown SocketServerLauncher');
-        this.currentConnections.forEach(connection => connection.dispose());
-        this.netServer.close();
-    }
 }

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

@@ -0,0 +1,164 @@
+/********************************************************************************
+ * Copyright (c) 2023 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
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * 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 * as http from 'http';
+import { Container, inject, injectable } from 'inversify';
+import * as net from 'net';
+import * as jsonrpc from 'vscode-jsonrpc';
+import { Server, WebSocket } from 'ws';
+import { GLSPServerLauncher } from '../../common/launch/glsp-server-launcher';
+import { GLSPServer, JsonRpcGLSPServer } from '../../common/protocol/glsp-server';
+import { Logger } from '../../common/utils/logger';
+import { START_UP_COMPLETE_MSG } from './socket-server-launcher';
+
+export interface WebSocketServerOptions {
+    host?: string;
+    port?: number;
+    path: string;
+}
+
+export interface ResolvedWebSocketServerOptions {
+    host?: string;
+    port: number;
+    path: string;
+    server: http.Server;
+}
+
+export interface WebsocketConnectionData {
+    socket: WebSocket;
+    connection: jsonrpc.MessageConnection;
+}
+
+const STATUS_UPGRADE_REQUIRED = 426;
+
+@injectable()
+export class WebSocketServerLauncher extends GLSPServerLauncher<WebSocketServerOptions> {
+    @inject(Logger)
+    protected override logger: Logger;
+
+    protected server: Server;
+    protected startupCompleteMessage = START_UP_COMPLETE_MSG;
+    protected currentConnections: jsonrpc.MessageConnection[] = [];
+
+    constructor() {
+        super();
+        this.toDispose.push(
+            Disposable.create(() => {
+                this.currentConnections.forEach(connection => connection.dispose());
+                this.server.close();
+            })
+        );
+    }
+
+    protected async run(options: WebSocketServerOptions): Promise<void> {
+        const resolvedOptions = await this.resolveOptions(options);
+        this.server = new Server({ 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) => {
+            this.createClientConnection(ws);
+        });
+
+        return new Promise((resolve, reject) => {
+            this.server.on('close', () => resolve(undefined));
+            this.server.on('error', error => reject(error));
+        });
+    }
+
+    protected async createClientConnection(socket: WebSocket): Promise<void> {
+        const container = this.createContainer();
+        const connection = this.createConnection(socket);
+        this.currentConnections.push(connection);
+        const glspServer = container.get<JsonRpcGLSPServer>(JsonRpcGLSPServer);
+        glspServer.connect(connection);
+        this.logger.info('Starting GLSP server connection');
+        connection.listen();
+        connection.onDispose(() => this.disposeClientConnection(container, glspServer));
+        socket.on('close', () => this.disposeClientConnection(container, glspServer));
+        connection.onClose(() => console.log('GOD dam'));
+        return new Promise((resolve, rejects) => {
+            connection.onClose(() => resolve(undefined));
+            connection.onError(error => rejects(error));
+        });
+    }
+
+    protected disposeClientConnection(container: Container, glspServer: GLSPServer): void {
+        glspServer.shutdown();
+        container.unbindAll();
+    }
+
+    protected createConnection(socket: WebSocket): jsonrpc.MessageConnection {
+        return createWebSocketConnection(wrapWebSocket(socket));
+    }
+
+    protected async resolveOptions(options: WebSocketServerOptions): Promise<ResolvedWebSocketServerOptions> {
+        const port = !options.port || options.port === 0 ? await getFreePort() : options.port;
+        const path = options.path.startsWith('/') ? options.path : `/${options.path}`;
+        const server = this.createHttpServer(port, options.host);
+
+        return { ...options, port, path, server };
+    }
+
+    protected createHttpServer(port: number, host?: string): http.Server {
+        const server = http.createServer((req, res) => {
+            const body = http.STATUS_CODES[STATUS_UPGRADE_REQUIRED];
+
+            res.writeHead(426, {
+                'Content-Length': body?.length,
+                'Content-Type': 'text/plain'
+            });
+            res.end(body);
+        });
+        server.listen(port, host);
+        // Set server timeout to infinite
+        server.setTimeout(0);
+        return server;
+    }
+
+    override start(options: WebSocketServerOptions): MaybePromise<void> {
+        super.start(options);
+    }
+}
+
+async function getFreePort(): Promise<number> {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.listen(0, () => {
+            const address = srv.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('Could not address to compute a free port'));
+                return;
+            }
+            srv.close(() => resolve(address.port));
+        });
+    });
+}
+/**
+ * Creates a {@link WebSocketWrapper} for the given plain WebSocket
+ * @param socket The socket to wrap
+ */
+export function wrapWebSocket(socket: WebSocket): WebSocketWrapper {
+    return {
+        send: content => socket.send(content),
+        onMessage: cb => socket.on('message', cb),
+        onClose: cb => socket.on('close', cb),
+        onError: cb => socket.on('error', cb),
+        dispose: () => socket.close()
+    };
+}