@gitpod/gitpod-protocol 0.1.5-wth-argo.0 → 0.1.5-wth-test.41

package/src/messaging/browser/connection.ts

@@ -5,13 +5,17 @@
  * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
  */
 
-import { listen as doListen, Logger, ConsoleLogger } from "vscode-ws-jsonrpc";
+import { Logger, ConsoleLogger, toSocket, IWebSocket } from "vscode-ws-jsonrpc";
+import { createMessageConnection } from "vscode-jsonrpc";
+import { AbstractMessageWriter } from "vscode-jsonrpc/lib/messageWriter";
+import { AbstractMessageReader } from "vscode-jsonrpc/lib/messageReader";
 import { JsonRpcProxyFactory, JsonRpcProxy } from "../proxy-factory";
-import { ConnectionHandler } from "../handler";
-import ReconnectingWebSocket from 'reconnecting-websocket';
+import { ConnectionEventHandler, ConnectionHandler } from "../handler";
+import ReconnectingWebSocket, { Event } from 'reconnecting-websocket';
 
 export interface WebSocketOptions {
     onerror?: (event: Event) => void;
+    onListening?: (socket: ReconnectingWebSocket) => void;
 }
 
 export class WebSocketConnectionProvider {
@@ -23,19 +27,35 @@ export class WebSocketConnectionProvider {
      * An optional target can be provided to handle
      * notifications and requests from a remote side.
      */
-    createProxy<T extends object>(path: string, target?: object, options?: WebSocketOptions): JsonRpcProxy<T> {
+    createProxy<T extends object>(path: string | Promise<string>, target?: object, options?: WebSocketOptions): JsonRpcProxy<T> {
         const factory = new JsonRpcProxyFactory<T>(target);
-        this.listen({
-            path,
-            onConnection: c => factory.listen(c)
-        }, options);
+        const startListening = (path: string) => {
+            const socket = this.listen({
+                path,
+                onConnection: c => factory.listen(c),
+            }, {
+                onTransportDidClose: () => factory.fireConnectionClosed(),
+                onTransportDidOpen: () => factory.fireConnectionOpened(),
+            },
+                options
+            );
+            if (options?.onListening) {
+                options.onListening(socket as any as ReconnectingWebSocket)
+            }
+        };
+
+        if (typeof path === "string") {
+            startListening(path);
+        } else {
+            path.then(path => startListening(path));
+        }
         return factory.createProxy();
     }
 
     /**
      * Install a connection handler for the given path.
      */
-    listen(handler: ConnectionHandler, options?: WebSocketOptions): void {
+    listen(handler: ConnectionHandler, eventHandler: ConnectionEventHandler, options?: WebSocketOptions): WebSocket {
         const url = handler.path;
         const webSocket = this.createWebSocket(url);
 
@@ -50,11 +70,13 @@ export class WebSocketConnectionProvider {
                 logger.error(JSON.stringify(error));
             });
         }
-        doListen({
-            webSocket,
-            onConnection: connection => handler.onConnection(connection),
-            logger
-        });
+        doListen(
+            webSocket as any as ReconnectingWebSocket,
+            handler,
+            eventHandler,
+            logger,
+        );
+        return webSocket;
     }
 
     protected createLogger(): Logger {
@@ -76,3 +98,162 @@ export class WebSocketConnectionProvider {
     }
 
 }
+
+// The following was extracted from vscode-ws-jsonrpc to make these changes:
+//  - switch from WebSocket to ReconnectingWebSocket
+//  - webSocket.onopen: making sure it's only ever called once so we're re-using MessageConnection
+//  - WebSocketMessageWriter: buffer and re-try messages instead of throwing an error immidiately
+//  - WebSocketMessageReader: don't close MessageConnection on 'socket.onclose'
+function doListen(resocket: ReconnectingWebSocket, handler: ConnectionHandler, eventHandler: ConnectionEventHandler, logger: Logger) {
+    resocket.addEventListener("close", () => eventHandler.onTransportDidClose());
+
+    let alreadyOpened = false;
+    resocket.onopen = () => {
+        // trigerr "open" every time we re-open the underlying websocket
+        eventHandler.onTransportDidOpen();
+
+        // make sure we're only ever creating one MessageConnection, irregardless of how many times we have to re-open the underlying (reconnecting) websocket
+        if (alreadyOpened) {
+            return;
+        }
+        alreadyOpened = true;
+
+        const connection = createWebSocketConnection(resocket, logger);
+        handler.onConnection(connection);
+    };
+}
+
+function createWebSocketConnection(resocket: ReconnectingWebSocket, logger: Logger) {
+    const socket = toSocket(resocket as any);
+    const messageReader = new NonClosingWebSocketMessageReader(socket);
+    const messageWriter = new BufferingWebSocketMessageWriter(resocket, logger);
+    const connection = createMessageConnection(messageReader, messageWriter, logger);
+    connection.onClose(() => connection.dispose());
+    return connection;
+}
+
+/**
+ * This takes vscode-ws-jsonrpc/lib/socket/writer/WebSocketMessageWriter and adds a buffer
+ */
+class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
+    protected readonly socket: ReconnectingWebSocket;
+    protected readonly logger: Logger;
+    protected errorCount: number = 0;
+
+    protected buffer: any[] = [];
+
+    constructor(socket: ReconnectingWebSocket, logger: Logger) {
+        super();
+        this.socket = socket;
+        this.logger = logger;
+
+        socket.addEventListener("open", (event: Event) => this.flushBuffer());
+    }
+
+    write(msg: any) {
+        if (this.socket.readyState !== ReconnectingWebSocket.OPEN) {
+            this.bufferMsg(msg);
+            return;
+        }
+
+        try {
+            const content = JSON.stringify(msg);
+            this.socket.send(content);
+        } catch (e) {
+            this.errorCount++;
+            this.fireError(e, msg, this.errorCount);
+
+            this.bufferMsg(msg);
+        }
+    }
+
+    protected flushBuffer() {
+        if (this.buffer.length === 0) {
+            return
+        }
+
+        const buffer = [...this.buffer];
+        this.buffer = [];
+        for (const msg of buffer) {
+            this.write(msg);
+        }
+        //this.logger.info(`flushed buffer (${this.buffer.length})`)
+    }
+
+    protected bufferMsg(msg: any) {
+        this.buffer.push(msg);
+        //this.logger.info(`buffered message (${this.buffer.length})`);
+    }
+}
+
+
+/**
+ * This takes vscode-ws-jsonrpc/lib/socket/reader/WebSocketMessageReader and removes the "onClose -> fireClose" connection
+ */
+class NonClosingWebSocketMessageReader extends AbstractMessageReader {
+    protected readonly socket: IWebSocket;
+    protected readonly events: any[] = [];
+    protected state: 'initial' | 'listening' | 'closed' = 'initial';
+    protected callback: (message: any) => void = () => {};
+
+    constructor(socket: IWebSocket) {
+        super();
+        this.socket = socket;
+        this.socket.onMessage(message => this.readMessage(message));
+        this.socket.onError(error => this.fireError(error));
+        this.socket.onClose((code, reason) => {
+            if (code !== 1000) {
+                const error = {
+                    name: '' + code,
+                    message: `Error during socket reconnect: code = ${code}, reason = ${reason}`
+                };
+                this.fireError(error);
+            }
+            // this.fireClose();        // <-- reason for this class to be copied over
+        });
+    }
+    listen(callback: (message: any) => void) {
+        if (this.state === 'initial') {
+            this.state = 'listening';
+            this.callback = callback;
+            while (this.events.length !== 0) {
+                const event = this.events.pop();
+                if (event.message) {
+                    this.readMessage(event.message);
+                }
+                else if (event.error) {
+                    this.fireError(event.error);
+                }
+                else {
+                    this.fireClose();
+                }
+            }
+        }
+    }
+    readMessage(message: any) {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { message });
+        }
+        else if (this.state === 'listening') {
+            const data = JSON.parse(message);
+            this.callback(data);
+        }
+    }
+    fireError(error: any) {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { error });
+        }
+        else if (this.state === 'listening') {
+            super.fireError(error);
+        }
+    }
+    fireClose() {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, {});
+        }
+        else if (this.state === 'listening') {
+            super.fireClose();
+        }
+        this.state = 'closed';
+    }
+}

package/src/messaging/client-call-metrics.ts

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+import { injectable } from 'inversify';
+import * as prometheusClient from 'prom-client';
+
+type GrpcMethodType = 'unary' | 'client_stream' | 'server_stream' | 'bidi_stream';
+export interface IGrpcCallMetricsLabels {
+	service: string,
+	method: string,
+	type: GrpcMethodType,
+}
+
+export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
+	code: string
+}
+
+export const IClientCallMetrics = Symbol("IClientCallMetrics");
+
+export interface IClientCallMetrics {
+	started(labels: IGrpcCallMetricsLabels) : void;
+    sent(labels: IGrpcCallMetricsLabels) : void;
+    received(labels: IGrpcCallMetricsLabels) : void;
+    handled(labels: IGrpcCallMetricsLabelsWithCode) : void;
+}
+
+@injectable()
+export class PrometheusClientCallMetrics implements IClientCallMetrics {
+
+	readonly startedCounter: prometheusClient.Counter<string>;
+	readonly sentCounter: prometheusClient.Counter<string>;
+	readonly receivedCounter: prometheusClient.Counter<string>;
+	readonly handledCounter: prometheusClient.Counter<string>;
+
+	constructor() {
+		this.startedCounter = new prometheusClient.Counter({
+			name: 'grpc_client_started_total',
+			help: 'Total number of RPCs started on the client.',
+			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
+			registers: [prometheusClient.register]
+		});
+		this.sentCounter = new prometheusClient.Counter({
+			name: 'grpc_client_msg_sent_total',
+			help: ' Total number of gRPC stream messages sent by the client.',
+			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
+			registers: [prometheusClient.register]
+		});
+		this.receivedCounter = new prometheusClient.Counter({
+			name: 'grpc_client_msg_received_total',
+			help: 'Total number of RPC stream messages received by the client.',
+			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
+			registers: [prometheusClient.register]
+		});
+		this.handledCounter = new prometheusClient.Counter({
+			name: 'grpc_client_handled_total',
+			help: 'Total number of RPCs completed by the client, regardless of success or failure.',
+			labelNames: ['grpc_service', 'grpc_method', 'grpc_type', 'grpc_code'],
+			registers: [prometheusClient.register]
+		});
+	}
+
+	started(labels: IGrpcCallMetricsLabels): void {
+		this.startedCounter.inc({
+			grpc_service: labels.service,
+			grpc_method: labels.method,
+			grpc_type: labels.type
+		});
+	}
+
+	sent(labels: IGrpcCallMetricsLabels): void {
+		this.sentCounter.inc({
+			grpc_service: labels.service,
+			grpc_method: labels.method,
+			grpc_type: labels.type
+		});
+	}
+
+	received(labels: IGrpcCallMetricsLabels): void {
+		this.receivedCounter.inc({
+			grpc_service: labels.service,
+			grpc_method: labels.method,
+			grpc_type: labels.type
+		});
+	}
+
+	handled(labels: IGrpcCallMetricsLabelsWithCode): void {
+		this.handledCounter.inc({
+			grpc_service: labels.service,
+			grpc_method: labels.method,
+			grpc_type: labels.type,
+			grpc_code: labels.code
+		});
+	}
+}

package/src/messaging/error.ts

@@ -34,6 +34,9 @@ export namespace ErrorCodes {
     // 460 Context Parse Error (custom status code)
     export const CONTEXT_PARSE_ERROR = 460;
 
+    // 461 Invalid gitpod yml
+    export const INVALID_GITPOD_YML = 461;
+
     // 450 Payment error
     export const PAYMENT_ERROR = 450;
 
@@ -64,12 +67,15 @@ export namespace ErrorCodes {
     // 555 EE License Required
     export const EE_LICENSE_REQUIRED = 555;
 
+    // 601 SaaS Feature
+    export const SAAS_FEATURE = 601;
+
     // 610 Invalid Team Subscription Quantity
     export const TEAM_SUBSCRIPTION_INVALID_QUANTITY = 610;
 
     // 620 Team Subscription Assignment Failed
     export const TEAM_SUBSCRIPTION_ASSIGNMENT_FAILED = 620;
 
-    // 666 Not Implemented TODO IO-SPLIT remove
-    export const NOT_IMPLEMENTED = 666;
+    // 630 Snapshot Error
+    export const SNAPSHOT_ERROR = 630;
 }

package/src/messaging/handler.ts

@@ -13,3 +13,15 @@ export interface ConnectionHandler {
     readonly path: string;
     onConnection(connection: MessageConnection, session?: object): void;
 }
+
+export interface ConnectionEventHandler {
+    /**
+     * Called when the transport underpinning the connection got closed
+     */
+     onTransportDidClose(): void;
+
+     /**
+      * Called when the transport underpinning the connection is (re-)opened
+      */
+     onTransportDidOpen(): void;
+}

package/src/messaging/node/connection.ts

@@ -65,13 +65,13 @@ export function toIWebSocket(webSocket: ws) {
         send: content => {
             if (webSocket.readyState !== ws.OPEN) {
                 if (sendsAfterOpen++ > 3) {
-                    log.error(`Repeated try to send on closed web socket (readyState was ${webSocket.readyState})`, { ws });
+                    //log.debug(`Repeated try to send on closed web socket (readyState was ${webSocket.readyState})`, { ws });
                 }
                 return;
             }
             webSocket.send(content, err => {
                 if (err) {
-                    log.error('Error in ws.send()', err, { ws });
+                    log.error('error in ws.send()', err, { ws });
                 }
             })
         },

package/src/messaging/proxy-factory.ts

@@ -105,13 +105,19 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
             this.connectionPromiseResolve = resolve
         );
         this.connectionPromise.then(connection => {
-            connection.onClose(() =>
-                this.onDidCloseConnectionEmitter.fire(undefined)
-            );
-            this.onDidOpenConnectionEmitter.fire(undefined);
+            connection.onClose(() => this.fireConnectionClosed());
+            this.fireConnectionOpened();
         });
     }
 
+    fireConnectionClosed() {
+        this.onDidCloseConnectionEmitter.fire(undefined)
+    }
+
+    fireConnectionOpened() {
+        this.onDidOpenConnectionEmitter.fire(undefined);
+    }
+
     /**
      * Connect a MessageConnection to the factory.
      *
@@ -158,7 +164,9 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * methods calls.
      */
     protected onNotification(method: string, ...args: any[]): void {
-        this.target[method](...args);
+        if (this.target[method]) {
+            this.target[method](...args);
+        }
     }
 
     /**
@@ -214,7 +222,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
                     try {
                         if (isNotify) {
                             connection.sendNotification(p.toString(), ...args);
-                            resolve();
+                            resolve(undefined);
                         } else {
                             const resultPromise = connection.sendRequest(p.toString(), ...args) as Promise<any>;
                             resultPromise

package/src/payment-protocol.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+ export namespace PaymentProtocol {
+    export const UPDATE_GITPOD_SUBSCRIPTION_PATH = '/payment/chargebee'
+}
+
+export interface PlanCoupon {
+    chargebeePlanID: string;
+    newPrice: number;
+    description: string;
+}
+
+export interface GithubUpgradeURL {
+    url: string;
+    planID: number;
+}

package/src/permission.ts

@@ -14,7 +14,8 @@ export const Permissions = {
     "admin-users": undefined,
     "admin-workspaces": undefined,
     "admin-api": undefined,
-    "ide-settings": undefined
+    "ide-settings": undefined,
+    "new-workspace-cluster": undefined,
 };
 export type PermissionName = keyof (typeof Permissions);
 export const Roles = {"devops": undefined, "viewer": undefined, "admin": undefined };