@eclipse-glsp/server 1.1.0-next.3d7585d.42

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

@@ -0,0 +1,73 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { expect } from 'chai';
+import { LogLevel } from '../../common/utils/logger';
+import { createSocketCliParser, defaultSocketLaunchOptions, SocketLaunchOptions } from './socket-cli-parser';
+
+describe('test createCliParser', () => {
+    const parser = createSocketCliParser();
+
+    parser.command.exitOverride();
+    const argv = ['/usr/bin/node', 'test'];
+
+    it('parse - no args', () => {
+        const options = parser.parse(argv);
+        expect(options).to.deep.equal(defaultSocketLaunchOptions);
+    });
+
+    it('parse - invalid port (below lower range)', () => {
+        expect(() => parser.parse([...argv, '--port', '-1'])).to.throw();
+    });
+
+    it('parse - invalid port (below upper range)', () => {
+        expect(() => parser.parse([...argv, '--port', '65536'])).to.throw();
+    });
+
+    it('parse - valid port', () => {
+        const port = 3000;
+        const result = parser.parse([...argv, '--port', '3000']);
+        expect(result.port).to.equal(port);
+    });
+
+    it('parse - --no-consoleLog', () => {
+        const result = parser.parse([...argv, '--no-consoleLog']);
+        expect(result.consoleLog).false;
+    });
+
+    it('parse - --fileLog', () => {
+        const result = parser.parse([...argv, '--fileLog']);
+        expect(result.fileLog).true;
+    });
+
+    it('parse - custom host name', () => {
+        const host = 'docker.internal';
+        const result = parser.parse([...argv, '--host', host]);
+        expect(result.host, host);
+    });
+
+    it('parse- no args with custom default options', () => {
+        const options: SocketLaunchOptions = {
+            logDir: '.myLogDir',
+            logLevel: LogLevel.debug,
+            consoleLog: true,
+            fileLog: true,
+            host: 'myHost',
+            port: 3000
+        };
+        const result = createSocketCliParser(options).parse(argv);
+        expect(result).to.deep.equal(options);
+    });
+});

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

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 * as cmd from 'commander';
+import { CliParser, createCliParser, defaultLaunchOptions, LaunchOptions } from './cli-parser';
+
+export interface SocketLaunchOptions extends LaunchOptions {
+    port: number;
+    host: string;
+}
+
+export const defaultSocketLaunchOptions: Required<SocketLaunchOptions> = {
+    ...defaultLaunchOptions,
+    port: 5007,
+    host: 'localhost'
+};
+
+export function createSocketCliParser<O extends SocketLaunchOptions = SocketLaunchOptions>(
+    defaultOptions: SocketLaunchOptions = defaultSocketLaunchOptions
+): CliParser<O> {
+    const parser = createCliParser<O>(defaultOptions);
+    parser.command
+        .option('-p , --port <port>', `Set server port [default= ${defaultOptions.port}]`, processPort, defaultOptions.port)
+        .option('--host <host>', `Set host name [default= ${defaultOptions.host}`, defaultOptions.host)
+        .option('--no-consoleLog', 'Disable console logging')
+        .option('--fileLog', 'Enable file logging', defaultOptions.fileLog);
+    return parser;
+}
+
+export function processPort(value: string): number {
+    const port = Number.parseInt(value, 10);
+    if (isNaN(port)) {
+        throw new cmd.InvalidArgumentError('Port is not a number!');
+    }
+    if (port < 0 || port > 65535) {
+        throw new cmd.InvalidArgumentError('Port has to be between in range (0,65535)!');
+    }
+
+    return port;
+}

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

@@ -0,0 +1,68 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { expect } from 'chai';
+import { Container } from 'inversify';
+import * as net from 'net';
+import { createAppModule } from '../di/app-module';
+import { defaultSocketLaunchOptions } from './socket-cli-parser';
+import { SocketServerLauncher } from './socket-server-launcher';
+const severPort = 5008;
+describe('test SocketServerLauncher', () => {
+    it('starts and stops', async () => {
+        const appContainer = new Container();
+        appContainer.load(createAppModule(defaultSocketLaunchOptions));
+        const launcher = appContainer.resolve(SocketServerLauncher);
+        launcher.start({ port: severPort });
+        const sockStart = new net.Socket();
+        sockStart.setTimeout(100);
+        const startPromise = new Promise(res => {
+            sockStart
+                .on('connect', () => {
+                    expect(true);
+                    sockStart.destroy();
+                    res(true);
+                })
+                .on('error', e => {
+                    expect.fail('Server is not reachable: ' + e.message);
+                })
+                .on('timeout', () => {
+                    expect.fail('Connection time outed.');
+                })
+                .connect(severPort);
+        });
+        await startPromise;
+        launcher.shutdown();
+        const sockStop = new net.Socket();
+        sockStop.setTimeout(100);
+        const stopPromise = new Promise(res => {
+            sockStop
+                .on('connect', () => {
+                    expect.fail('Server still reachable.');
+                })
+                .on('error', () => {
+                    expect(true);
+                    sockStop.destroy();
+                    res(true);
+                })
+                .on('timeout', () => {
+                    expect.fail('Connection time outed.');
+                })
+                .connect(severPort);
+        });
+        await stopPromise;
+    });
+});

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

@@ -0,0 +1,90 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { Container, inject, injectable } from 'inversify';
+import * as net from 'net';
+import * as jsonrpc from 'vscode-jsonrpc/node';
+import { GLSPServerLauncher } from '../../common/launch/glsp-server-launcher';
+import { GLSPServer, JsonRpcGLSPServer } from '../../common/protocol/glsp-server';
+import { Logger } from '../../common/utils/logger';
+
+const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed. Accepting requests on port:';
+@injectable()
+export class SocketServerLauncher extends GLSPServerLauncher<net.TcpSocketConnectOpts> {
+    @inject(Logger) protected override logger: Logger;
+
+    protected currentConnections: jsonrpc.MessageConnection[] = [];
+    protected startupCompleteMessage = START_UP_COMPLETE_MSG;
+    protected netServer: net.Server;
+
+    protected run(opts: net.TcpSocketConnectOpts): Promise<void> {
+        this.netServer = net.createServer(socket => this.createClientConnection(socket));
+
+        this.netServer.listen(opts.port, opts.host);
+        this.netServer.on('listening', () => {
+            const addressInfo = this.netServer.address();
+            if (!addressInfo) {
+                this.logger.error('Could not resolve GLSP Server address info. Shutting down.');
+                this.shutdown();
+                return;
+            } else if (typeof addressInfo === 'string') {
+                this.logger.error(`GLSP Server is unexpectedly listening to pipe or domain socket "${addressInfo}". Shutting down.`);
+                this.shutdown();
+                return;
+            }
+            const currentPort = addressInfo.port;
+            this.logger.info(`The GLSP server is ready to accept new client requests on port: ${currentPort}`);
+            // Print a message to the output stream that indicates that the start is completed.
+            // This indicates to the client that the server process is ready (in an embedded scenario).
+            console.log(this.startupCompleteMessage.concat(currentPort.toString()));
+        });
+        this.netServer.on('error', () => this.shutdown());
+        return new Promise((resolve, reject) => {
+            this.netServer.on('close', () => resolve(undefined));
+            this.netServer.on('error', error => reject(error));
+        });
+    }
+
+    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);
+    }
+
+    protected stop(): void {
+        this.logger.info('Shutdown SocketServerLauncher');
+        this.currentConnections.forEach(connection => connection.dispose());
+        this.netServer.close();
+    }
+}