@gitpod/gitpod-protocol 0.1.5-prs-core-dev-kubeconfig.4 → 0.1.5-prs-test-dazzle-rewrite.68

package/src/ide-protocol.ts

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+
+/**
+ * `IDEServer` provides a list of available IDEs.
+ */
+export interface IDEServer {
+    /**
+     * Returns the IDE preferences.
+     */
+    getIDEOptions(): Promise<IDEOptions>;
+}
+
+export interface IDEOptions {
+    /**
+     * A list of available IDEs.
+     */
+    options: { [key: string]: IDEOption };
+
+    /**
+     * The default (browser) IDE when the user has not specified one.
+     */
+    defaultIde: string;
+
+    /**
+     * The default desktop IDE when the user has not specified one.
+     */
+    defaultDesktopIde: string;
+}
+
+export interface IDEOption {
+    /**
+     * To ensure a stable order one can set an `orderKey`.
+     */
+    orderKey?: string;
+
+    /**
+     * Human readable title text of the IDE (plain text only).
+     */
+    title: string;
+
+    /**
+     * The type of the IDE, currently 'browser' or 'desktop'.
+     */
+    type: 'browser' | 'desktop';
+
+    /**
+    * The logo for the IDE. That could be a key in (see
+    * components/dashboard/src/images/ideLogos.ts) or a URL.
+    */
+    logo: string;
+
+    /**
+     * Text of an optional tooltip (plain text only).
+     */
+    tooltip?: string;
+
+    /**
+     * Text of an optional label next to the IDE option like “Insiders” (plain
+     * text only).
+     */
+    label?: string;
+
+    /**
+     * Notes to the IDE option that are renderd in the preferences when a user
+     * chooses this IDE.
+     */
+    notes?: string[];
+
+    /**
+    * If `true` this IDE option is not visible in the IDE preferences.
+    */
+    hidden?: boolean;
+
+    /**
+     * The image ref to the IDE image.
+     */
+    image: string;
+
+    /**
+     * When this is `true`, the tag of this image is resolved to the latest
+     * image digest regularly.
+     *
+     * This is useful if this image points to a tag like `nightly` that will be
+     * updated regularly. When `resolveImageDigest` is `true`, we make sure that
+     * we resolve the tag regularly to the most recent image version.
+     */
+    resolveImageDigest?: boolean;
+}

package/src/index.ts

@@ -17,3 +17,5 @@ export * from './email-protocol';
 export * from './headless-workspace-log';
 export * from './context-url';
 export * from './teams-projects-protocol';
+export * from './snapshot-url';
+export * from './oss-allowlist';

package/src/messaging/browser/connection.ts

@@ -5,10 +5,13 @@
  * 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;
@@ -29,7 +32,10 @@ export class WebSocketConnectionProvider {
         const startListening = (path: string) => {
             const socket = this.listen({
                 path,
-                onConnection: c => factory.listen(c)
+                onConnection: c => factory.listen(c),
+            }, {
+                onTransportDidClose: () => factory.fireConnectionClosed(),
+                onTransportDidOpen: () => factory.fireConnectionOpened(),
             },
                 options
             );
@@ -49,7 +55,7 @@ export class WebSocketConnectionProvider {
     /**
      * Install a connection handler for the given path.
      */
-    listen(handler: ConnectionHandler, options?: WebSocketOptions): WebSocket {
+    listen(handler: ConnectionHandler, eventHandler: ConnectionEventHandler, options?: WebSocketOptions): WebSocket {
         const url = handler.path;
         const webSocket = this.createWebSocket(url);
 
@@ -64,11 +70,12 @@ 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;
     }
 
@@ -91,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

@@ -76,6 +76,6 @@ export namespace ErrorCodes {
     // 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

@@ -7,71 +7,27 @@
 
 import * as ws from "ws";
 import * as http from "http";
-import * as https from "https";
-import * as url from "url";
 import * as net from "net";
-import { MessageConnection } from "vscode-jsonrpc";
-import { createWebSocketConnection, IWebSocket } from "vscode-ws-jsonrpc";
+import { IWebSocket } from "vscode-ws-jsonrpc";
 import { log } from '../../util/logging';
 
-export interface IServerOptions {
-    readonly server: http.Server | https.Server;
-    readonly path?: string;
-    matches?(request: http.IncomingMessage): boolean;
-}
-
-export function createServerWebSocketConnection(options: IServerOptions, onConnect: (connection: MessageConnection) => void): void {
-    openJsonRpcSocket(options, socket => {
-        onConnect(createWebSocketConnection(socket, console));
-    });
-}
-
-export function openJsonRpcSocket(options: IServerOptions, onOpen: (socket: IWebSocket) => void): void {
-    openSocket(options, socket => {
-        const webSocket = toIWebSocket(socket);
-        onOpen(webSocket);
-    });
-}
-
 export interface OnOpen {
     (webSocket: ws, request: http.IncomingMessage, socket: net.Socket, head: Buffer): void;
 }
 
-export function openSocket(options: IServerOptions, onOpen: OnOpen): void {
-    const wss = new ws.Server({
-        noServer: true,
-            perMessageDeflate: {
-                // don't compress if a message is less than 256kb
-                threshold: 256 * 1024
-            }
-    });
-    options.server.on('upgrade', (request: http.IncomingMessage, socket: net.Socket, head: Buffer) => {
-        const pathname = request.url ? url.parse(request.url).pathname : undefined;
-        if (options.path && pathname === options.path || options.matches && options.matches(request)) {
-            wss.handleUpgrade(request, socket, head, webSocket => {
-                if (webSocket.readyState === webSocket.OPEN) {
-                    onOpen(webSocket, request, socket, head);
-                } else {
-                    webSocket.on('open', () => onOpen(webSocket, request, socket, head));
-                }
-            });
-        }
-    });
-}
-
 export function toIWebSocket(webSocket: ws) {
     let sendsAfterOpen = 0;
     return <IWebSocket>{
         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);
+        }
     }
 
     /**

package/src/oss-allowlist.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 interface OssAllowList {
+    /**
+     * A string that identifies a GitHub/GitLab/Bitbucket identity of the form "<host>/<profilename>"
+     * E.g., "github.com/geropl"
+     */
+    identity: string,
+
+    deleted?: boolean,
+}

package/src/permission.ts

@@ -16,7 +16,6 @@ export const Permissions = {
     "admin-api": undefined,
     "ide-settings": undefined,
     "new-workspace-cluster": undefined,
-    "teams-and-projects": undefined,
 };
 export type PermissionName = keyof (typeof Permissions);
 export const Roles = {"devops": undefined, "viewer": undefined, "admin": undefined };