@eclipse-glsp/server 1.1.0-next.3d7585d.42 → 1.1.0-next.42963d6.55

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;
 
@@ -34,13 +33,13 @@ export abstract class GLSPServerLauncher<T = undefined> {
         this._modules.push(serverModule, ...additionalModules);
     }
 
-    createContainer(): Container {
+    createContainer(...additionalModules: ContainerModule[]): Container {
         const container = this.parentContainer ? this.parentContainer.createChild() : new Container();
-        container.load(...this._modules);
+        container.load(...this._modules, ...additionalModules);
         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/launch/jsonrpc-server-launcher.ts

@@ -0,0 +1,95 @@
+/********************************************************************************
+ * 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 {
+    Disposable,
+    GLSPClientProxy,
+    GLSPServer,
+    JsonrpcClientProxy,
+    JsonrpcGLSPClient,
+    configureClientConnection
+} from '@eclipse-glsp/protocol';
+import { Container, ContainerModule, inject, injectable } from 'inversify';
+import * as jsonrpc from 'vscode-jsonrpc';
+import { Logger } from '../utils/logger';
+import { GLSPServerLauncher } from './glsp-server-launcher';
+
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
+
+export interface JsonRpcServerInstance {
+    server: GLSPServer;
+    clientConnection: jsonrpc.MessageConnection;
+    container: Container;
+}
+
+@injectable()
+export abstract class JsonRpcGLSPServerLauncher<T> extends GLSPServerLauncher<T> {
+    @inject(Logger)
+    protected override logger: Logger;
+
+    protected serverInstances = new Map<jsonrpc.MessageConnection, JsonRpcServerInstance>();
+    protected startupCompleteMessage = START_UP_COMPLETE_MSG;
+
+    constructor() {
+        super();
+        this.toDispose.push(
+            Disposable.create(() => {
+                this.serverInstances.forEach(instance => this.disposeServerInstance(instance));
+            })
+        );
+    }
+
+    protected disposeServerInstance(instance: JsonRpcServerInstance): void {
+        this.serverInstances.delete(instance.clientConnection);
+        instance.server.shutdown();
+        instance.container.unbindAll();
+        instance.clientConnection.dispose();
+    }
+
+    protected createServerInstance(clientConnection: jsonrpc.MessageConnection): void {
+        const container = this.createContainer(this.createJsonRpcModule(clientConnection));
+        const server = container.get<GLSPServer>(GLSPServer);
+        const instance = { container, clientConnection, server };
+        this.serverInstances.set(clientConnection, instance);
+        this.configureClientConnection(instance);
+    }
+
+    protected createJsonRpcModule(clientConnection: jsonrpc.MessageConnection): ContainerModule {
+        return new ContainerModule(bind => {
+            bind(GLSPClientProxy).toDynamicValue(ctx => {
+                const proxy = ctx.container.resolve(JsonrpcClientProxy);
+                proxy.initialize(clientConnection);
+                return proxy;
+            });
+        });
+    }
+
+    protected configureClientConnection(serverInstance: JsonRpcServerInstance): void {
+        configureClientConnection(serverInstance.clientConnection, serverInstance.server);
+
+        serverInstance.clientConnection.onNotification(JsonrpcGLSPClient.ShutdownNotification, () =>
+            this.disposeServerInstance(serverInstance)
+        );
+
+        this.logger.info('Starting GLSP server connection');
+    }
+
+    protected createClientProxy(serverInstance: JsonRpcServerInstance): GLSPClientProxy {
+        const proxy = serverInstance.container.resolve(JsonrpcClientProxy);
+        proxy.initialize(serverInstance.clientConnection);
+        return proxy;
+    }
+}

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

@@ -13,26 +13,28 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CompoundOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { CompoundOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { OperationActionHandler } from './operation-action-handler';
+import { Command, CompoundCommand } from '../command/command';
 import { OperationHandler } from './operation-handler';
 import { OperationHandlerRegistry } from './operation-handler-registry';
 
 @injectable()
-export class CompoundOperationHandler implements OperationHandler {
-    operationType = CompoundOperation.KIND;
+export class CompoundOperationHandler extends OperationHandler {
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
 
-    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
+    operationType = CompoundOperation.KIND;
 
-    execute(operation: CompoundOperation): void {
-        operation.operationList.forEach(nestedOperation => this.executeNestedOperation(nestedOperation));
-    }
+    async createCommand(operation: CompoundOperation): Promise<Command | undefined> {
+        const maybeCommands = operation.operationList.map(op => this.operationHandlerRegistry.getExecutableCommand(op));
+        const commands: Command[] = [];
 
-    executeNestedOperation(operation: Operation): MaybePromise<void> {
-        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
-        if (operationHandler) {
-            operationHandler.execute(operation);
+        for await (const command of maybeCommands) {
+            if (command) {
+                commands.push(command);
+            }
         }
+        return new CompoundCommand(commands);
     }
 }

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

@@ -13,94 +13,37 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement } from '@eclipse-glsp/graph';
 import {
     CreateEdgeOperation,
     CreateNodeOperation,
-    CreateOperation,
-    MaybePromise,
-    Operation,
-    Point,
+    hasArrayProp,
+    hasFunctionProp,
+    hasStringProp,
     TriggerEdgeCreationAction,
     TriggerNodeCreationAction
 } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { getRelativeLocation } from '../utils/layout-util';
 import { OperationHandler } from './operation-handler';
 
 /**
  * A special {@link OperationHandler} that is responsible for the handling of {@link CreateOperation}s. Depending on its
  * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
  */
-@injectable()
-export abstract class CreateOperationHandler implements OperationHandler {
-    abstract operationType: string;
-    abstract readonly label: string;
-    abstract elementTypeIds: string[];
-
-    abstract execute(operation: Operation): MaybePromise<void>;
-
-    /**
-     * Returns a list of {@link TriggerElementCreationAction}s for registered element types.
-     *
-     * @returns A list of {@link TriggerElementCreationAction}s.
-     */
-    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[] {
-        if (this.operationType === CreateNodeOperation.KIND) {
-            return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
-        } else if (this.operationType === CreateEdgeOperation.KIND) {
-            return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
-        }
-        return [];
-    }
-
-    handles(operation: CreateOperation): boolean {
-        return this.elementTypeIds.includes(operation.elementTypeId);
-    }
+export interface CreateOperationHandler extends OperationHandler {
+    readonly label: string;
+    elementTypeIds: string[];
+    operationType: CreateOperationKind;
+    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[];
 }
 
-/**
- * Abstract base implementation for {@link CreateOperationHandler} that
- * create an element that is represented with a {@link GNode} in the graphical model.
- */
-@injectable()
-export abstract class CreateNodeOperationHandler extends CreateOperationHandler {
-    @inject(ModelState)
-    protected modelState: ModelState;
-
-    get operationType(): string {
-        return CreateNodeOperation.KIND;
-    }
-
-    /**
-     * Retrieve the graphical model element that should contain the newly created {@link GNode}.
-     * If `undefined` is returned the {@link GNode} should be added directly to the diagram root.
-     * @param operation The currently handled operation.
-     * @returns The container {@link GModeElement} or `undefined`.
-     */
-    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
-        const index = this.modelState.index;
-        return operation.containerId ? index.get(operation.containerId) : undefined;
-    }
-
-    getLocation(operation: CreateNodeOperation): Point | undefined {
-        return operation.location;
-    }
+export type CreateOperationKind = typeof CreateNodeOperation.KIND | typeof CreateEdgeOperation.KIND;
 
-    /**
-     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
-     * and converts the absolute location to coordinates relative to the given container.
-     *  Relative coordinates can only be retrieved if the given container element is part of
-     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
-     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
-     * @param absoluteLocation The diagram absolute position.
-     * @param container The container element.
-     * @returns The relative position or `undefined`.
-     */
-    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
-        const container = this.getContainer(operation) ?? this.modelState.root;
-        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
-        return getRelativeLocation(absoluteLocation, container);
+export namespace CreateOperationHandler {
+    export function is(object: unknown): object is CreateOperationHandler {
+        return (
+            object instanceof OperationHandler &&
+            hasStringProp(object, 'label') &&
+            hasArrayProp(object, 'elementTypeIds') &&
+            hasFunctionProp(object, 'getTriggerActions')
+        );
     }
 }

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

@@ -13,57 +13,81 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateOperation, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { Action, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../actions/action-handler';
+import { Command } from '../command/command';
+import { CommandStack } from '../command/command-stack';
 import { Operations } from '../di/service-identifiers';
 import { ModelState } from '../features/model/model-state';
 import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { GLSPServerError } from '../utils/glsp-server-error';
 import { OperationHandler } from './operation-handler';
 import { OperationHandlerRegistry } from './operation-handler-registry';
 
 @injectable()
 export class OperationActionHandler implements ActionHandler {
-    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
-    @inject(ModelSubmissionHandler) protected modelSubmissionHandler: ModelSubmissionHandler;
-    @inject(ModelState) protected modelState: ModelState;
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    @inject(ModelSubmissionHandler)
+    protected modelSubmissionHandler: ModelSubmissionHandler;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
 
     constructor(@inject(Operations) readonly actionKinds: string[]) {}
 
     execute(action: Operation): MaybePromise<Action[]> {
-        if (this.handles(action)) {
-            if (this.modelState.isReadonly) {
-                return [
-                    ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
-                        severity: 'WARNING'
-                    })
-                ];
-            }
-            const operationHandler = OperationActionHandler.getOperationHandler(action, this.operationHandlerRegistry);
-            if (operationHandler) {
-                return this.executeHandler(action, operationHandler);
-            }
+        if (!this.handles(action)) {
+            throw new GLSPServerError(`Unhandled operation kind: ${action.kind}`);
+        }
+        if (this.modelState.isReadonly) {
+            return [
+                ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
+                    severity: 'WARNING'
+                })
+            ];
+        }
+        return this.executeOperation(action);
+    }
+
+    protected executeOperation(operation: Operation): MaybePromise<Action[]> {
+        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
+        if (operationHandler) {
+            return this.executeHandler(operation, operationHandler);
         }
         return [];
     }
 
-    async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
-        // TODO: Create GModelRecordingCommand;
-        await handler.execute(operation);
-        this.modelState.index.indexRoot(this.modelState.root);
-        this.modelState.isDirty = true;
-        // TODO: this.modelState.execute(command)
+    protected async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+        const command = await handler.execute(operation);
+        if (command) {
+            await this.executeCommand(command);
+        }
+        return this.modelSubmissionHandler.submitModel('operation');
+    }
+
+    protected async executeCommand(command: Command): Promise<void> {
+        return this.commandStack.execute(command);
+    }
+
+    protected submitModel(): MaybePromise<Action[]> {
         return this.modelSubmissionHandler.submitModel('operation');
     }
 
     handles(action: Action): boolean {
-        if (this.actionKinds.includes(action.kind)) {
-            return true;
-        }
-        return false;
+        return this.actionKinds.includes(action.kind);
     }
 
+    /**
+     *  @Deprecated Use {@link OperationHandlerRegistry#getOperationHandler(Operation) instead}.
+     */
+
     static getOperationHandler(operation: Operation, registry: OperationHandlerRegistry): OperationHandler | undefined {
-        return CreateOperation.is(operation) ? registry.get(`${operation.kind}_${operation.elementTypeId}`) : registry.get(operation.kind);
+        return registry.getOperationHandler(operation);
     }
 }

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

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Args } from '@eclipse-glsp/protocol';
+import { Args, CreateOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
+import { Command } from '../command/command';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { Registry } from '../utils/registry';
 import { CreateOperationHandler } from './create-operation-handler';
@@ -23,13 +24,27 @@ import { OperationHandler, OperationHandlerConstructor, OperationHandlerFactory
 @injectable()
 export class OperationHandlerRegistry extends Registry<string, OperationHandler> {
     registerHandler(handler: OperationHandler): boolean {
-        if (handler instanceof CreateOperationHandler) {
+        if (CreateOperationHandler.is(handler)) {
             handler.elementTypeIds.forEach(typeId => this.register(`${handler.operationType}_${typeId}`, handler));
             return true;
         } else {
             return this.register(handler.operationType, handler);
         }
     }
+
+    getOperationHandler(operation: Operation): OperationHandler | undefined {
+        return CreateOperation.is(operation) ? this.get(`${operation.kind}_${operation.elementTypeId}`) : this.get(operation.kind);
+    }
+
+    /**
+     * Returns the matching command for the given operation.
+     *
+     * @param operation operation
+     * @return the matching command for the given operation
+     */
+    getExecutableCommand(operation: Operation): MaybePromise<Command | undefined> {
+        return this.getOperationHandler(operation)?.createCommand(operation);
+    }
 }
 
 @injectable()
@@ -44,7 +59,7 @@ export class OperationHandlerRegistryInitializer implements ClientSessionInitial
     @inject(OperationHandlerRegistry)
     protected registry: OperationHandlerRegistry;
 
-    initialize(args?: Args): void {
+    initialize(_args?: Args): void {
         const handlers = this.handlerConstructors.map(constructor => this.factory(constructor));
         handlers.forEach(handler => this.registry.registerHandler(handler));
     }

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

@@ -14,38 +14,63 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { MaybePromise, Operation } from '@eclipse-glsp/protocol';
-import { interfaces } from 'inversify';
-
-export const OperationHandler = Symbol('OperationHandler');
+import { inject, injectable, interfaces } from 'inversify';
+import { Command } from '../command/command';
+import { ModelState } from '../features/model/model-state';
 
 /**
  * An operation handler can execute {@link Operation}s of a certain type (subclass).
  * The operation handler processes the operation in the {@link OperationHandler.execute()} method. The result
- * of the execution is an update of the `ModelState` state.
- * This update is reversible (undo) and can be reapplied (redo). For basic diagram languages these updates are typically
- * applied directly on the `ModelState` using EMF `Command`s and the
- * `ModelState.execute()` method. For more complex diagram languages the
- * GModel state might be updated indirectly and the operation handler manipulates a custom model representation.
+ * of the execution is a {@link Command} that captures the corresponding source model changes.
+ * This command can be applied on the `CommandStack` and is reversible (undo) and can be reapplied (redo).
  *
  * The `OperationActionHandler` is responsible for retrieving all available (valid) operation handlers for an
  * operation that is dispatched via `ActionDispatcher`.
  */
-export interface OperationHandler {
+@injectable()
+export abstract class OperationHandler {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
     /**
      * Returns the operation type that can be handled by this operation handler.
      *
      * @returns the operation type that can be handled.
      */
-    readonly operationType: string;
+    abstract operationType: string;
 
     readonly label?: string;
 
     /**
-     * Executes the operation handler for the given {@link Operation}.
+     * Creates a command that performs the operation in the source model(s). If `undefined` is  returned, no update
+     * is performed on the model(s).
+     *
+     * @param operation The operation to process.
+     * @return The created command to be executed on the command stack or `undefined` nothing should be done.
+     */
+    abstract createCommand(operation: Operation): MaybePromise<Command | undefined>;
+
+    /**
+     * Executes the operation handler for the given {@link Operation} and returns the corresponding {@link Command}.
+     * If the given operation cannot be handled by this handler or the handler execution did not result in any changes
+     * `undefined` is returned.
+     *
+     * @param operation The operation that should be executed or empty if nothing should be done.
+     * @returns The command capturing the execution changes or `undefined`
+     */
+    execute(operation: Operation): MaybePromise<Command | undefined> {
+        return this.handles(operation) ? this.createCommand(operation) : undefined;
+    }
+
+    /**
+     * Validates whether the given {@link Operation} can be handled by this operation handler.
      *
-     * @param operation The operation that should be executed.
+     * @param operation The operation that should be validated.
+     * @returns `true` if the given operation can be handled, `false` otherwise.
      */
-    execute(operation: Operation): MaybePromise<void>;
+    handles(operation: Operation): boolean {
+        return this.modelState.root && operation.kind === this.operationType;
+    }
 }
 
 export const OperationHandlerConstructor = Symbol('OperationHandlerConstructor');

package/src/common/protocol/glsp-server.spec.ts

@@ -13,7 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DisposeClientSessionParameters, InitializeClientSessionParameters, InitializeParameters } from '@eclipse-glsp/protocol';
+import {
+    DisposeClientSessionParameters,
+    GLSPClientProxy,
+    GLSPServerListener,
+    InitializeClientSessionParameters,
+    InitializeParameters
+} from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import * as sinon from 'sinon';
@@ -21,9 +27,7 @@ import { GlobalActionProvider } from '../actions/global-action-provider';
 import { ClientSessionManager } from '../session/client-session-manager';
 import * as mock from '../test/mock-util';
 import { Logger } from '../utils/logger';
-import { GLSPClientProxy, JsonRpcGLSPClientProxy } from './glsp-client-proxy';
 import { DefaultGLSPServer } from './glsp-server';
-import { GLSPServerListener } from './glsp-server-listener';
 import assert = require('assert');
 
 describe('test DefaultGLSPServer', () => {
@@ -48,7 +52,6 @@ describe('test DefaultGLSPServer', () => {
         new ContainerModule(bind => {
             bind(Logger).toConstantValue(new mock.StubLogger());
             bind(GLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
-            bind(JsonRpcGLSPClientProxy).toConstantValue(new mock.StubGLSPClientProxy());
             bind(ClientSessionManager).toConstantValue(sessionManager);
             bind(GlobalActionProvider).toConstantValue({ clientActionKinds: new Map<string, string[]>(), serverActionKinds });
             bind(GLSPServerListener).toConstantValue(listener1);