@eclipse-glsp/server 1.1.0-next.385269d.45 → 1.1.0-next.3bba361.48

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,26 +14,27 @@
  * 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, START_UP_COMPLETE_MSG } from '../../common/index';
+import { MaybePromise } from '../../common/index';
+import { JsonRpcGLSPServerLauncher, JsonRpcServerInstance } from '../../common/launch/jsonrpc-server-launcher';
+export interface WorkerLaunchOptions {
+    context?: Worker;
+}
+
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed.';
 
 @injectable()
-export class WorkerServerLauncher extends GLSPServerLauncher {
-    private connection?: jsonrpc.MessageConnection;
+export class WorkerServerLauncher extends JsonRpcGLSPServerLauncher<WorkerLaunchOptions> {
+    protected connection?: jsonrpc.MessageConnection;
 
-    protected run(): MaybePromise<void> {
+    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();
-        const glspServer = container.get<JsonRpcGLSPServer>(JsonRpcGLSPServer);
-        glspServer.connect(this.connection);
-        this.connection.onDispose(() => this.disposeClientConnection(container, glspServer));
-
+        this.connection = this.createConnection(options);
+        this.createServerInstance(this.connection);
         this.logger.info('GLSP server worker connection established');
-        this.connection.listen();
         postMessage(START_UP_COMPLETE_MSG);
         return new Promise((resolve, rejects) => {
             this.connection?.onClose(() => resolve(undefined));
@@ -41,18 +42,15 @@ export class WorkerServerLauncher extends GLSPServerLauncher {
         });
     }
 
-    protected disposeClientConnection(container: Container, glspServer: GLSPServer): void {
-        glspServer.shutdown();
-        container.unbindAll();
+    protected override disposeServerInstance(instance: JsonRpcServerInstance): void {
+        super.disposeServerInstance(instance);
         this.connection = undefined;
     }
 
-    protected stop(): MaybePromise<void> {
-        this.logger.info('Shutdown WorkerServerLauncher');
-        this.connection?.dispose();
-    }
-
-    protected createConnection(): jsonrpc.MessageConnection {
-        return jsonrpc.createMessageConnection(new jsonrpc.BrowserMessageReader(self), new jsonrpc.BrowserMessageWriter(self));
+    protected createConnection(options: WorkerLaunchOptions): jsonrpc.MessageConnection {
+        return jsonrpc.createMessageConnection(
+            new jsonrpc.BrowserMessageReader(options.context ?? self),
+            new jsonrpc.BrowserMessageWriter(options.context ?? self)
+        );
     }
 }

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

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