@eclipse-glsp/server 1.1.0-RC06 → 1.1.0-next.146ae06.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/server",
-  "version": "1.1.0-RC06",
+  "version": "1.1.0-next.146ae06.49+146ae06",
   "description": "A js server framework for Eclipse GLSP",
   "keywords": [
     "eclipse",
@@ -59,8 +59,8 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/graph": "1.1.0-RC06",
-    "@eclipse-glsp/protocol": "1.1.0-RC06",
+    "@eclipse-glsp/graph": "1.1.0-next.146ae06.49+146ae06",
+    "@eclipse-glsp/protocol": "next",
     "@types/uuid": "8.3.1",
     "commander": "^8.3.0",
     "fast-json-patch": "^3.1.0",
@@ -75,5 +75,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "591801638567465e0210f5960f30343c2153fdd4"
+  "gitHead": "146ae06fdf2dcaea924873e830a81b0ca4033d85"
 }

package/src/browser/di/app-module.ts

@@ -14,42 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ContainerModule, interfaces } from 'inversify';
-import { InjectionContainer, Logger, LoggerFactory, LogLevel, ModuleContext, NullLogger } from '../../common/index';
-import { ConsoleLogger } from './console-logger';
+import { ContainerModule } from 'inversify';
+import { InjectionContainer, LogLevel, LoggerConfigOptions, configureConsoleLogger } from '../../common/';
 
-export interface LaunchOptions {
-    consoleLog?: boolean;
-    logLevel?: LogLevel;
-}
-export function createAppModule(options: LaunchOptions = {}): ContainerModule {
-    const resolvedOptions: LaunchOptions = { consoleLog: true, logLevel: LogLevel.info, ...options };
+export function createAppModule(options: LoggerConfigOptions = {}): ContainerModule {
+    const resolvedOptions: LoggerConfigOptions = { consoleLog: true, logLevel: LogLevel.info, ...options };
     return new ContainerModule((bind, unbind, isBound, rebind) => {
         bind(InjectionContainer).toDynamicValue(dynamicContext => dynamicContext.container);
         const context = { bind, unbind, isBound, rebind };
         configureConsoleLogger(context, resolvedOptions);
     });
 }
-
-export function configureConsoleLogger<T extends LaunchOptions>(context: ModuleContext, options: T): void {
-    if (!options.consoleLog) {
-        context.bind(Logger).to(NullLogger).inSingletonScope();
-    } else {
-        context.bind(Logger).toDynamicValue(ctx => new ConsoleLogger(options.logLevel, getRequestParentName(ctx)));
-    }
-    context.bind(LoggerFactory).toFactory(dynamicContext => (caller: string) => {
-        const logger = dynamicContext.container.get(Logger);
-        logger.caller = caller;
-        return logger;
-    });
-}
-
-function getRequestParentName(context: interfaces.Context): string | undefined {
-    if (context.currentRequest.parentRequest) {
-        const bindings = context.currentRequest.parentRequest.bindings;
-        if (bindings.length > 0) {
-            return bindings[0].implementationType?.name;
-        }
-    }
-    return undefined;
-}

package/src/browser/index.ts

@@ -15,5 +15,4 @@
  ********************************************************************************/
 export * from '../common/index';
 export * from './di/app-module';
-export * from './di/console-logger';
 export * from './launch/worker-server-launcher';

package/src/browser/launch/worker-server-launcher.ts

@@ -14,9 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Container, injectable } from 'inversify';
+import { injectable } from 'inversify';
 import * as jsonrpc from 'vscode-jsonrpc/browser';
-import { GLSPServer, GLSPServerLauncher, JsonRpcGLSPServer, MaybePromise } from '../../common/index';
+import { MaybePromise } from '../../common/index';
+import { JsonRpcGLSPServerLauncher, JsonRpcServerInstance } from '../../common/launch/jsonrpc-server-launcher';
 export interface WorkerLaunchOptions {
     context?: Worker;
 }
@@ -24,22 +25,16 @@ export interface WorkerLaunchOptions {
 export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed.';
 
 @injectable()
-export class WorkerServerLauncher extends GLSPServerLauncher<WorkerLaunchOptions> {
+export class WorkerServerLauncher extends JsonRpcGLSPServerLauncher<WorkerLaunchOptions> {
     protected connection?: jsonrpc.MessageConnection;
 
     protected run(options: WorkerLaunchOptions): MaybePromise<void> {
         if (this.connection) {
             throw new Error('Error during launch. Server already has an active client connection');
         }
-        const container = this.createContainer();
         this.connection = this.createConnection(options);
-        const glspServer = container.get<JsonRpcGLSPServer>(JsonRpcGLSPServer);
-        glspServer.connect(this.connection);
-        this.connection.onDispose(() => this.disposeClientConnection(container, glspServer));
-
+        this.createServerInstance(this.connection);
         this.logger.info('GLSP server worker connection established');
-        this.connection.listen();
-        this.toDispose.push(this.connection);
         postMessage(START_UP_COMPLETE_MSG);
         return new Promise((resolve, rejects) => {
             this.connection?.onClose(() => resolve(undefined));
@@ -47,9 +42,8 @@ export class WorkerServerLauncher extends GLSPServerLauncher<WorkerLaunchOptions
         });
     }
 
-    protected disposeClientConnection(container: Container, glspServer: GLSPServer): void {
-        glspServer.shutdown();
-        container.unbindAll();
+    protected override disposeServerInstance(instance: JsonRpcServerInstance): void {
+        super.disposeServerInstance(instance);
         this.connection = undefined;
     }
 

package/src/common/actions/client-action-handler.ts

@@ -13,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ActionMessage } from '@eclipse-glsp/protocol';
+import { Action, ActionMessage, GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import { ClientActionKinds, ClientId } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 
 /**
  * The client action handler is responsible of handling action kinds that are intended for the

package/src/common/command/command-stack.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { MaybePromise } from '..';
 import { Logger } from '../utils/logger';
 import { Command } from './command';
 

package/src/common/di/client-session-module.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import { ClientId } from './service-identifiers';
 
 export function createClientSessionModule(clientId: string, glspClient: GLSPClientProxy): ContainerModule {

package/src/common/di/glsp-module.ts

@@ -13,12 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { BindingContext } from '@eclipse-glsp/protocol';
 import { ContainerModule, injectable, interfaces } from 'inversify';
 import { AbstractMultiBinding } from './multi-binding';
 
 /**
  * A wrapper interface to get access to the binding related functions
  * for a inversify container.
+ * @deprecated Use `BindingContext` from `@eclipse-glsp/protocol` instead
  */
 export interface ModuleContext {
     bind: interfaces.Bind;
@@ -34,7 +36,7 @@ export interface ModuleContext {
 export abstract class GLSPModule extends ContainerModule {
     public static CLIENT_ACTIONS = 'ClientActions';
 
-    protected context: ModuleContext;
+    protected context: BindingContext;
 
     constructor() {
         super((bind, unbind, isBound, rebind) => {

package/src/common/di/multi-binding.ts

@@ -13,9 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { distinctAdd, flatPush, MaybeArray, remove } from '@eclipse-glsp/protocol';
+import { BindingContext, distinctAdd, flatPush, MaybeArray, remove } from '@eclipse-glsp/protocol';
 import { applyBindingTarget, BindingTarget } from './binding-target';
-import { ModuleContext } from './glsp-module';
 
 /**
  * A helper class used in `GLSPModules` to ease the configuration of multi-injected service identifiers.
@@ -29,7 +28,7 @@ export abstract class AbstractMultiBinding<T> {
 
     constructor(readonly identifier: string | symbol) {}
 
-    abstract applyBindings(context: ModuleContext): void;
+    abstract applyBindings(context: BindingContext): void;
 
     add(newBinding: T): void {
         distinctAdd(this.bindings, newBinding);
@@ -71,7 +70,7 @@ export abstract class AbstractMultiBinding<T> {
  * @typeparam T the base type of {@link BindingTarget}.
  */
 export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         this.bindings.forEach(binding => applyBindingTarget(context, this.identifier, binding));
     }
 }
@@ -83,7 +82,7 @@ export class MultiBinding<T> extends AbstractMultiBinding<BindingTarget<T>> {
  * * @typeparam T the type of the instances
  */
 export class InstanceMultiBinding<T> extends AbstractMultiBinding<T> {
-    applyBindings(context: ModuleContext): void {
+    applyBindings(context: BindingContext): void {
         context.bind(this.identifier).toConstantValue(this.bindings);
     }
 }

package/src/common/di/server-module.ts

@@ -13,14 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPServer, GLSPServerListener } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
 import { DefaultGlobalActionProvider, GlobalActionProvider } from '../actions/global-action-provider';
-import { DefaultGLSPClientProxy, GLSPClientProxy, JsonRpcGLSPClientProxy } from '../protocol/glsp-client-proxy';
-import { DefaultGLSPServer, GLSPServer, JsonRpcGLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
+import { DefaultGLSPServer } from '../protocol/glsp-server';
 import { ClientSessionFactory, DefaultClientSessionFactory } from '../session/client-session-factory';
 import { ClientSessionManager, DefaultClientSessionManager } from '../session/client-session-manager';
-import { applyBindingTarget, BindingTarget } from './binding-target';
+import { BindingTarget, applyBindingTarget } from './binding-target';
 import { DiagramModule } from './diagram-module';
 import { GLSPModule } from './glsp-module';
 import { MultiBinding } from './multi-binding';
@@ -74,7 +73,6 @@ export class ServerModule extends GLSPModule {
         applyBindingTarget(context, DiagramModules, this.bindDiagramModules());
 
         applyBindingTarget(context, GLSPServer, this.bindGLSPServer()).inSingletonScope();
-        applyBindingTarget(context, JsonRpcGLSPServer, this.bindJsonRpcGLSPServer());
         applyBindingTarget(context, ClientSessionFactory, this.bindClientSessionFactory()).inSingletonScope();
         applyBindingTarget(context, ClientSessionManager, this.bindClientSessionManager()).inSingletonScope();
         this.configureMultiBinding(new MultiBinding<GLSPServerListener>(GLSPServerListener), binding =>
@@ -83,10 +81,9 @@ export class ServerModule extends GLSPModule {
 
         applyBindingTarget(context, GlobalActionProvider, this.bindGlobalActionProvider()).inSingletonScope();
 
-        applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
-
-        applyBindingTarget(context, GLSPClientProxy, this.bindGLSPClientProxy()).inSingletonScope();
-        applyBindingTarget(context, JsonRpcGLSPClientProxy, this.bindJsonRpcGLSPClientProxy());
+        if (!isBound(InjectionContainer)) {
+            applyBindingTarget(context, InjectionContainer, this.bindInjectionContainer());
+        }
     }
 
     protected bindDiagramModules(): BindingTarget<Map<string, ContainerModule[]>> {
@@ -97,10 +94,6 @@ export class ServerModule extends GLSPModule {
         return DefaultGLSPServer;
     }
 
-    protected bindJsonRpcGLSPServer(): BindingTarget<JsonRpcGLSPServer> {
-        return { service: GLSPServer };
-    }
-
     protected bindClientSessionFactory(): BindingTarget<ClientSessionFactory> {
         return DefaultClientSessionFactory;
     }
@@ -117,14 +110,6 @@ export class ServerModule extends GLSPModule {
         return { dynamicValue: context => context.container };
     }
 
-    protected bindGLSPClientProxy(): BindingTarget<GLSPClientProxy> {
-        return DefaultGLSPClientProxy;
-    }
-
-    protected bindJsonRpcGLSPClientProxy(): BindingTarget<JsonRpcGLSPClientProxy> {
-        return { service: GLSPClientProxy };
-    }
-
     protected configureGLSPServerListeners(binding: MultiBinding<GLSPServerListener>): void {
         binding.add({ service: ClientSessionManager });
     }

package/src/common/features/model/model-submission-handler.ts

@@ -17,16 +17,20 @@ import { GModelRootSchema } from '@eclipse-glsp/graph';
 import {
     Action,
     DirtyStateChangeReason,
+    MarkersReason,
     MaybePromise,
     RequestBoundsAction,
     SetDirtyStateAction,
+    SetMarkersAction,
     SetModelAction,
     UpdateModelAction
 } from '@eclipse-glsp/protocol';
+
 import { inject, injectable, optional } from 'inversify';
 import { CommandStack } from '../../command/command-stack';
 import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
 import { LayoutEngine } from '../layout/layout-engine';
+import { ModelValidator } from '../validation/model-validator';
 import { GModelFactory } from './gmodel-factory';
 import { GModelSerializer } from './gmodel-serializer';
 import { ModelState } from './model-state';
@@ -52,6 +56,10 @@ export class ModelSubmissionHandler {
     @inject(CommandStack)
     protected commandStack: CommandStack;
 
+    @inject(ModelValidator)
+    @optional()
+    protected validator?: ModelValidator;
+
     /**
      * Returns a list of actions to update the client-side model, based on the specified <code>modelState</code>.
      *
@@ -101,6 +109,10 @@ export class ModelSubmissionHandler {
         if (!this.diagramConfiguration.needsClientLayout) {
             result.push(SetDirtyStateAction.create(this.commandStack.isDirty, { reason }));
         }
+        if (this.validator) {
+            const markers = await this.validator.validate([this.modelState.root], MarkersReason.LIVE);
+            result.push(SetMarkersAction.create(markers, { reason: MarkersReason.LIVE }));
+        }
         return result;
     }
 

package/src/common/features/validation/model-validator.ts

@@ -14,7 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { GModelElement } from '@eclipse-glsp/graph';
-import { Marker, MaybePromise } from '@eclipse-glsp/protocol';
+import { Marker, MarkersReason, MaybePromise } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
 
 export const ModelValidator = Symbol('ModelValidator');
 
@@ -28,7 +29,78 @@ export interface ModelValidator {
      * Validates the given list of {@link GModelElement}s and returns a list of {@link Marker}s.
      *
      * @param elements The list of {@link GModelElement} to validate.
-     * @returns A list of {@link Marker}s for the validated {@link GModelElement}s.
+     * @param reason The reason for a validation request, such as "batch" or "live" validation.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}s.
      */
-    validate(elements: GModelElement[]): MaybePromise<Marker[]>;
+    validate(elements: GModelElement[], reason?: string): MaybePromise<Marker[]>;
+}
+
+@injectable()
+export abstract class AbstractModelValidator implements ModelValidator {
+    validate(elements: GModelElement[], reason: string): Marker[] {
+        const markers: Marker[] = [];
+        for (const element of elements) {
+            if (MarkersReason.LIVE === reason) {
+                markers.push(...this.doLiveValidation(element));
+            } else if (MarkersReason.BATCH === reason) {
+                markers.push(...this.doBatchValidation(element));
+            } else {
+                markers.push(...this.doValidationForCustomReason(element));
+            }
+            if (element.children) {
+                markers.push(...this.validate(element.children, reason));
+            }
+        }
+        return markers;
+    }
+
+    /**
+     * Perform the live validation rules for the given <code>element</code>.
+     *
+     * This will be invoked on start and after each operation for all elements.
+     * Thus, the validation should be rather inexpensive.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doLiveValidation(element: GModelElement): Marker[] {
+        return [];
+    }
+
+    /**
+     * Perform the batch validation rules for the given <code>element</code>.
+     *
+     * <p>
+     * This will be invoked on demand by the client.
+     * Thus, the validation can include more expensive validation rules.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     * </p>
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doBatchValidation(element: GModelElement): Marker[] {
+        return [];
+    }
+
+    /**
+     * Perform a validation for a custom <code>reason</code> with the given <code>element</code>.
+     *
+     * <p>
+     * GLSP editors may add custom reasons for triggering a validation, other than <code>live</code> and
+     * <code>batch</code>.
+     * Validation requests that are not live or batch validations will be handled by this method.
+     * There is no need to traverse through the children in this method as {@link #validate(List, String)} will invoke
+     * this method for all children anyway.
+     * </p>
+     *
+     * @param element The element to validate.
+     * @return A list of {@link Marker}s for the validated {@link GModelElement}.
+     */
+    doValidationForCustomReason(element: GModelElement): Marker[] {
+        return [];
+    }
 }

package/src/common/features/validation/request-markers-handler.ts

@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GGraph } from '@eclipse-glsp/graph';
-import { Action, Marker, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
+import { Action, MarkersReason, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
 import { GLSPServerError } from '../../utils/glsp-server-error';
@@ -38,14 +37,9 @@ export class RequestMarkersHandler implements ActionHandler {
             elementIDs = [this.modelState.root.id];
         }
 
-        let markers: Marker[] = [];
-        const currentModelIndex = this.modelState.index;
-        for (const elementID of elementIDs) {
-            const modelElement = currentModelIndex.findByClass(elementID, GGraph);
-            if (modelElement) {
-                markers = markers.concat(await this.validator.validate([modelElement]));
-            }
-        }
+        const modelElements = this.modelState.index.getAll(elementIDs);
+        const markers = await this.validator.validate(modelElements, action.reason ?? MarkersReason.BATCH);
+
         return [SetMarkersAction.create(markers)];
     }
 }

package/src/common/index.ts

@@ -74,9 +74,7 @@ export * from './operations/create-operation-handler';
 export * from './operations/operation-action-handler';
 export * from './operations/operation-handler';
 export * from './operations/operation-handler-registry';
-export * from './protocol/glsp-client-proxy';
 export * from './protocol/glsp-server';
-export * from './protocol/glsp-server-listener';
 export * from './session/client-session';
 export * from './session/client-session-factory';
 export * from './session/client-session-initializer';
@@ -84,6 +82,7 @@ export * from './session/client-session-listener';
 export * from './session/client-session-manager';
 export * from './utils/args-util';
 export * from './utils/client-options-util';
+export * from './utils/console-logger';
 export * from './utils/glsp-server-error';
 export * from './utils/layout-util';
 export * from './utils/logger';

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

@@ -33,9 +33,9 @@ export abstract class GLSPServerLauncher<T> implements Disposable {
         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;
     }
 

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/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);