@eclipse-glsp/server 1.1.0-RC07 → 1.1.0-RC08

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

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

@@ -18,134 +18,26 @@ import {
     Args,
     DisposeClientSessionParameters,
     distinctAdd,
+    GLSPClientProxy,
+    GLSPServer,
+    GLSPServerListener,
     InitializeClientSessionParameters,
     InitializeParameters,
     InitializeResult,
-    JsonrpcGLSPClient,
     MaybePromise,
     remove,
     ServerActions,
     ServerMessageAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional } from 'inversify';
-import * as jsonrpc from 'vscode-jsonrpc';
-import { MessageConnection } from 'vscode-jsonrpc';
 import { GlobalActionProvider } from '../actions/global-action-provider';
 import { ClientSession } from '../session/client-session';
 import { ClientSessionManager } from '../session/client-session-manager';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';
-import { JsonRpcGLSPClientProxy } from './glsp-client-proxy';
-import { GLSPServerListener } from './glsp-server-listener';
-
-export const GLSPServer = Symbol('GLSPServer');
-
-/**
- * Interface for implementations of a server component using json-rpc for client-server communication.
- * Based on the specification of the Graphical Language Server Protocol:
- * https://github.com/eclipse-glsp/glsp/blob/master/PROTOCOL.md
- */
-export interface GLSPServer {
-    /**
-     *
-     * The `initialize` request has to be the first request from the client to the server. Until the server has responded
-     * with an {@link InitializeResult} no other request or notification can be handled and is expected to throw an
-     * error. A client is uniquely identified by an `applicationId` and has to specify on which `protocolVersion` it is
-     * based on. In addition, custom arguments can be provided in the `args` map to allow for custom initialization
-     * behavior on the server.
-     *
-     * After successfully initialization all {@link GLSPServerListener}s are notified via the
-     * {@link GLSPServerListener.serverInitialized} method.
-     *
-     * @param params the {@link InitializeParameters}.
-     * @returns A promise of the {@link InitializeResult} .
-     *
-     * @throws {@link Error} Subsequent initialize requests return the {@link InitializeResult} of the initial request
-     * if the given application id and protocol version are matching, otherwise the promise rejects with an error.
-     *
-     */
-    initialize(params: InitializeParameters): Promise<InitializeResult>;
-
-    /**
-     * The `initializeClientSession` request is sent to the server whenever a new graphical representation (diagram) is
-     * created. Each individual diagram on the client side counts as one session and has to provide a unique
-     * `clientSessionId` and its `diagramType`. In addition, custom arguments can be provided in the `args` map to allow
-     * for custom initialization behavior on the server. Subsequent `initializeClientSession` requests for the same
-     * client id and diagram type are expected to resolve successfully but don't have an actual effect because the
-     * corresponding client session is  already initialized.
-     *
-     * @param params the {@link InitializeClientSessionParameters}.
-     * @returns A promise that completes when the initialization was successful.
-     */
-    initializeClientSession(params: InitializeClientSessionParameters): Promise<void>;
-
-    /**
-     * The 'DisposeClientSession' request is sent to the server when a graphical representation (diagram) is no longer
-     * needed, e.g. the tab containing the diagram widget has been closed. The session is identified by its unique
-     * `clientSessionId`. In addition, custom arguments can be provided in the `args` map to allow for custom dispose
-     * behavior on the server.
-     *
-     * @param params the {@link DisposeClientSessionParameters}.
-     * @returns A `void` promise that completes if the disposal was successful.
-     *
-     */
-    disposeClientSession(params: DisposeClientSessionParameters): Promise<void>;
-
-    /**
-     * A `process` notification is sent from the client to server when the server should handle i.e. process a specific
-     * {@link ActionMessage}. Any communication that is performed between initialization and shutdown is handled by
-     * sending action messages, either from the client to the server or from the server to the client. This is the core
-     * part of the Graphical Language Server Protocol.
-     *
-     * @param message The {@link ActionMessage} that should be processed.
-     */
-    process(message: ActionMessage): void;
-
-    /**
-     * The `shutdown` notification is sent from the client to the server if the client disconnects from the server (e.g.
-     * the client application has been closed).
-     * This gives the server a chance to clean up and dispose any resources dedicated to the client and its sessions.
-     * All {@link GLSPServerListener}s are notified via the {@link GLSPServerListener.serverShutDown} method.
-     * Afterwards the server instance is considered to be disposed and can no longer be used for handling requests.
-     *
-     */
-    shutdown(): void;
-
-    /**
-     * Register a new {@link GLSPServerListener}.
-     *
-     * @param listener The listener that should be registered.
-     * @returns `true` if the listener was registered successfully, `false` otherwise (e.g. listener is already
-     *         registered).
-     */
-    addListener(listener: GLSPServerListener): boolean;
-
-    /**
-     * Unregister a {@link GLSPServerListener}.
-     *
-     * @param listener The listener that should be removed
-     * @returns 'true' if the listener was unregistered successfully, `false` otherwise (e.g. listener is was not
-     *         registered in the first place).
-     */
-    removeListener(listener: GLSPServerListener): boolean;
-
-    /**
-     * get a {@link ClientSession}.
-     *
-     * @param sessionId The id of the session to get
-     * @returns The either the ClientSession or undefined, if no ClientSession was found for the given id.
-     */
-    getClientSession(sessionId: string): ClientSession | undefined;
-}
-
-export const JsonRpcGLSPServer = Symbol('JsonRpcGLSPServer');
-
-export interface JsonRpcGLSPServer extends GLSPServer {
-    connect(connection: jsonrpc.MessageConnection): void;
-}
 
 @injectable()
-export class DefaultGLSPServer implements JsonRpcGLSPServer {
+export class DefaultGLSPServer implements GLSPServer {
     public static readonly PROTOCOL_VERSION = '1.0.0';
 
     @inject(Logger)
@@ -157,8 +49,9 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
     @inject(GlobalActionProvider)
     protected actionProvider: GlobalActionProvider;
 
-    @inject(JsonRpcGLSPClientProxy)
-    protected glspClient: JsonRpcGLSPClientProxy;
+    @inject(GLSPClientProxy)
+    @optional()
+    protected glspClientProxy?: GLSPClientProxy;
 
     protected initializeResult?: InitializeResult;
 
@@ -172,18 +65,6 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         serverListeners.forEach(listener => this.addListener(listener));
     }
 
-    protected setupJsonRpc(connection: MessageConnection): void {
-        connection.onRequest(JsonrpcGLSPClient.InitializeRequest.method, (params: InitializeParameters) => this.initialize(params));
-        connection.onRequest(JsonrpcGLSPClient.InitializeClientSessionRequest, (params: InitializeClientSessionParameters) =>
-            this.initializeClientSession(params)
-        );
-        connection.onRequest(JsonrpcGLSPClient.DisposeClientSessionRequest, (params: DisposeClientSessionParameters) =>
-            this.disposeClientSession(params)
-        );
-        connection.onNotification(JsonrpcGLSPClient.ActionMessageNotification, message => this.process(message));
-        connection.onNotification(JsonrpcGLSPClient.ShutdownNotification, () => this.shutdown());
-    }
-
     protected validateProtocolVersion(params: InitializeParameters): void {
         if (params.protocolVersion !== DefaultGLSPServer.PROTOCOL_VERSION) {
             throw new Error(
@@ -237,6 +118,7 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         this.validateServerInitialized();
 
         const session = this.sessionManager.getOrCreateClientSession(params);
+
         this.clientSessions.set(params.clientSessionId, session);
         return this.handleInitializeClientSessionArgs(params.args);
     }
@@ -281,7 +163,15 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
             errorMsg = reason.message;
         }
         const errorAction = ServerMessageAction.create(errorMsg, { severity: 'ERROR', details });
-        this.glspClient.process({ clientId: message.clientId, action: errorAction });
+        this.sendToClient({ clientId: message.clientId, action: errorAction });
+    }
+
+    protected sendToClient(message: ActionMessage): void {
+        if (this.glspClientProxy) {
+            this.glspClientProxy.process(message);
+            return;
+        }
+        throw new Error("Could not send message to client. No 'GLSPClientProxy' is connected");
     }
 
     getClientSession(sessionId: string): ClientSession | undefined {
@@ -295,11 +185,6 @@ export class DefaultGLSPServer implements JsonRpcGLSPServer {
         this.initializeResult = undefined;
     }
 
-    public connect(connection: jsonrpc.MessageConnection): void {
-        this.setupJsonRpc(connection);
-        this.glspClient.connect(connection);
-    }
-
     protected isInitialized(): boolean {
         return this.initializeResult !== undefined;
     }

package/src/common/session/client-session-factory.spec.ts

@@ -13,11 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { GLSPClientProxy } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
 import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import * as mock from '../test/mock-util';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';

package/src/common/session/client-session-factory.ts

@@ -13,12 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { InitializeClientSessionParameters } from '@eclipse-glsp/protocol';
+import { GLSPClientProxy, InitializeClientSessionParameters } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
 import { createClientSessionModule } from '../di/client-session-module';
 import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { ClientSession, DefaultClientSession } from './client-session';
 import { ClientSessionInitializer } from './client-session-initializer';

package/src/common/session/client-session-manager.ts

@@ -13,10 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { InitializeClientSessionParameters, remove } from '@eclipse-glsp/protocol';
+import { GLSPServer, GLSPServerListener, InitializeClientSessionParameters, remove } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { GLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { ClientSession } from './client-session';
 import { ClientSessionFactory } from './client-session-factory';

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

@@ -23,6 +23,9 @@ import {
     Args,
     CreateNodeOperation,
     EdgeTypeHint,
+    GLSPClientProxy,
+    GLSPServer,
+    GLSPServerListener,
     InitializeClientSessionParameters,
     MaybeArray,
     MaybePromise,
@@ -41,15 +44,12 @@ import { DiagramConfiguration, ServerLayoutKind } from '../diagram/diagram-confi
 import { ContextEditValidator } from '../features/directediting/context-edit-validator';
 import { LabelEditValidator } from '../features/directediting/label-edit-validator';
 import { GModelCreateEdgeOperationHandler, GModelCreateNodeOperationHandler } from '../gmodel/index';
-import { JsonRpcGLSPClientProxy } from '../protocol/glsp-client-proxy';
-import { GLSPServer } from '../protocol/glsp-server';
-import { GLSPServerListener } from '../protocol/glsp-server-listener';
 import { ClientSession } from '../session/client-session';
 import { ClientSessionFactory } from '../session/client-session-factory';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { ClientSessionListener } from '../session/client-session-listener';
 import { ClientSessionManager } from '../session/client-session-manager';
-import { Logger, LogLevel } from '../utils/logger';
+import { LogLevel, Logger } from '../utils/logger';
 
 export async function delay(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -194,7 +194,7 @@ export class StubClientSessionListener implements ClientSessionListener {
     sessionDisposed(clientSession: ClientSession): void {}
 }
 
-export class StubGLSPClientProxy implements JsonRpcGLSPClientProxy {
+export class StubGLSPClientProxy implements GLSPClientProxy {
     connect(connection: MessageConnection): void {}
 
     process(message: ActionMessage<Action>): void {}

package/src/{browser/di → common/utils}/console-logger.ts

@@ -14,9 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { BindingContext } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { Logger, LogLevel } from '../../common/index';
+import { LogLevel, Logger, LoggerConfigOptions, LoggerFactory, NullLogger, getRequestParentName } from './logger';
 
+/**
+ *  Simple logger implementation that forwards logging calls to the `console` and
+ *  can be used in both the browser and node context.
+ */
 @injectable()
 export class ConsoleLogger extends Logger {
     constructor(public logLevel: LogLevel = LogLevel.none, public caller?: string) {
@@ -69,3 +74,16 @@ export class ConsoleLogger extends Logger {
         return JSON.stringify(param, undefined, 4);
     }
 }
+
+export function configureConsoleLogger<T extends LoggerConfigOptions>(context: BindingContext, 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;
+    });
+}

package/src/common/utils/logger.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
+import { injectable, interfaces } from 'inversify';
 
 @injectable()
 export abstract class Logger {
@@ -70,3 +70,18 @@ export function asLogLevel(level: string | number): LogLevel | undefined {
     }
     return undefined;
 }
+
+export interface LoggerConfigOptions {
+    consoleLog?: boolean;
+    logLevel?: LogLevel;
+}
+
+export 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/node/di/app-module.ts

@@ -13,9 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule, interfaces } from 'inversify';
+import { BindingContext } from '@eclipse-glsp/protocol';
+import { ContainerModule } from 'inversify';
 import * as winston from 'winston';
-import { InjectionContainer, Logger, LoggerFactory, LogLevel, ModuleContext } from '../../common/index';
+import { InjectionContainer, LogLevel, Logger, LoggerFactory, getRequestParentName } from '../../common';
 import { LaunchOptions } from '../launch/cli-parser';
 import { WinstonLogger } from './winston-logger';
 
@@ -68,7 +69,7 @@ export function createWinstonInstance<T extends LaunchOptions>(options: T): wins
  * @param baseLoggerCreator The underling global {@link winston.Logger} instance.
  */
 export function configureWinstonLogger<T extends LaunchOptions>(
-    context: ModuleContext,
+    context: BindingContext,
     options: T,
     rebind = true,
     baseLoggerCreator: (launchOptions: T) => winston.Logger = createWinstonInstance
@@ -90,13 +91,3 @@ export function configureWinstonLogger<T extends LaunchOptions>(
         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/node/launch/cli-parser.ts

@@ -16,13 +16,12 @@
 import * as cmd from 'commander';
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { asLogLevel, LogLevel } from '../../common/utils/logger';
+import { LogLevel, LoggerConfigOptions, asLogLevel } from '../../common/utils/logger';
 
-export interface LaunchOptions {
+export interface LaunchOptions extends LoggerConfigOptions {
     logLevel: LogLevel;
     logDir?: string;
     fileLog: boolean;
-    consoleLog: boolean;
 }
 
 export interface CliParser<O extends LaunchOptions = LaunchOptions> {

package/src/node/launch/socket-cli-parser.ts

@@ -23,7 +23,7 @@ export interface SocketLaunchOptions extends LaunchOptions {
 
 export const defaultSocketLaunchOptions: Required<SocketLaunchOptions> = {
     ...defaultLaunchOptions,
-    port: 5007,
+    port: 0,
     host: 'localhost'
 };
 

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

@@ -14,9 +14,12 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { GLSPServer } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import * as net from 'net';
+import * as sinon from 'sinon';
+import { DefaultGLSPServer } from '../../common/protocol/glsp-server';
 import { createAppModule } from '../di/app-module';
 import { defaultSocketLaunchOptions } from './socket-cli-parser';
 import { SocketServerLauncher } from './socket-server-launcher';
@@ -24,7 +27,10 @@ const severPort = 5008;
 describe('test SocketServerLauncher', () => {
     it('starts and stops', async () => {
         const appContainer = new Container();
+        const serverStub = sinon.createStubInstance(DefaultGLSPServer);
         appContainer.load(createAppModule(defaultSocketLaunchOptions));
+
+        appContainer.bind(GLSPServer).toConstantValue(serverStub);
         const launcher = appContainer.resolve(SocketServerLauncher);
         launcher.start({ port: severPort });
         const sockStart = new net.Socket();

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

@@ -13,36 +13,35 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Container, inject, injectable } from 'inversify';
+import { Disposable } from '@eclipse-glsp/protocol';
+import { 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 { JsonRpcGLSPServerLauncher } from '../../common/launch/jsonrpc-server-launcher';
 import { Logger } from '../../common/utils/logger';
 
 export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
 
 @injectable()
-export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnectOpts> {
+export class SocketServerLauncher extends JsonRpcGLSPServerLauncher<net.TcpSocketConnectOpts> {
     @inject(Logger) protected override logger: Logger;
 
-    protected currentConnections: jsonrpc.MessageConnection[] = [];
-    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));
+        this.netServer = net.createServer(socket => {
+            const connection = this.createConnection(socket);
+            this.createServerInstance(connection);
+        });
 
         this.netServer.listen(opts.port, opts.host);
         this.netServer.on('listening', () => {
@@ -69,27 +68,6 @@ export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnec
         });
     }
 
-    protected async createClientConnection(socket: net.Socket): 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 for client: '${socket.localAddress}'`);
-        connection.listen();
-        connection.onDispose(() => this.disposeClientConnection(container, glspServer));
-        socket.on('close', () => this.disposeClientConnection(container, glspServer));
-        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: net.Socket): jsonrpc.MessageConnection {
         return jsonrpc.createMessageConnection(new jsonrpc.SocketMessageReader(socket), new jsonrpc.SocketMessageWriter(socket), console);
     }