@gitpod/gitpod-protocol 0.1.5-test.9 → 0.1.5-tweak-workspaceconfig-origin-docs-fork.0

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * Copyright (c) 2020 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.
  */
@@ -13,4 +13,8 @@ export * from './license-protocol';
 export * from './workspace-instance';
 export * from './permission';
 export * from './admin-protocol';
-export * from './email-protocol';
+export * from './email-protocol';
+export * from './headless-workspace-log';
+export * from './context-url';
+export * from './teams-projects-protocol';
+export * from './snapshot-url';

package/src/license-protocol.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * Copyright (c) 2020 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.
  */

package/src/messaging/browser/connection.ts

@@ -5,17 +5,19 @@
  * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
  */
 
-import { injectable } from "inversify";
-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;
 }
 
-@injectable()
 export class WebSocketConnectionProvider {
 
     /**
@@ -25,21 +27,37 @@ 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, options);
+        const webSocket = this.createWebSocket(url);
 
         const logger = this.createLogger();
         if (options && options.onerror) {
@@ -52,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 {
@@ -66,16 +86,174 @@ export class WebSocketConnectionProvider {
     /**
      * Creates a web socket for the given url
      */
-    createWebSocket(url: string, options?: WebSocketOptions): WebSocket {
-        const socketOptions = {
+    createWebSocket(url: string): WebSocket {
+        return new ReconnectingWebSocket(url, undefined, {
             maxReconnectionDelay: 10000,
             minReconnectionDelay: 1000,
             reconnectionDelayGrowFactor: 1.3,
             maxRetries: Infinity,
-            debug: false
-        };
-        const result = new ReconnectingWebSocket(url, undefined, socketOptions);
-        return result as any; //HACK ReconnectingWebScoket does not fully implement the WebScoket type.
+            debug: false,
+            WebSocket: WebSocket
+        }) as any;
+    }
+
+}
+
+// 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/browser/window-connection.ts

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2020 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 { Message } from 'vscode-jsonrpc/lib/messages';
+import { AbstractMessageWriter, MessageWriter } from 'vscode-jsonrpc/lib/messageWriter';
+import { AbstractMessageReader, MessageReader, DataCallback } from 'vscode-jsonrpc/lib/messageReader';
+import { MessageConnection, createMessageConnection } from 'vscode-jsonrpc/lib/main';
+import { ConsoleLogger } from 'vscode-ws-jsonrpc';
+
+interface WindowMessage extends Message {
+    serviceId: string
+}
+function isWindowMessage(value: any): value is WindowMessage {
+    return !!value && typeof value === 'object' &&
+        ('jsonrpc' in value && typeof value['jsonrpc'] === 'string') &&
+        ('serviceId' in value && typeof value['serviceId'] === 'string');
+}
+
+export class WindowMessageWriter extends AbstractMessageWriter implements MessageWriter {
+
+    constructor(readonly serviceId: string, readonly window: Window, readonly targetOrigin: string) {
+        super();
+    }
+
+    write(msg: Message): void {
+        const { serviceId } = this;
+        this.window.postMessage(Object.assign(msg, { serviceId }), this.targetOrigin);
+    }
+
+}
+
+export class WindowMessageReader extends AbstractMessageReader implements MessageReader {
+
+    protected callback?: DataCallback;
+    protected readonly buffer: Message[] = [];
+
+    constructor(readonly serviceId: string, readonly sourceOrigin: string) {
+        super();
+        window.addEventListener('message', event => {
+            if (this.sourceOrigin !== '*' && event.origin !== this.sourceOrigin) {
+                return;
+            }
+            if (!isWindowMessage(event.data) || event.data.serviceId !== this.serviceId) {
+                return;
+            }
+            if (this.callback) {
+                this.callback(event.data);
+            } else {
+                this.buffer.push(event.data);
+            }
+        }, false);
+    }
+
+    listen(callback: DataCallback): void {
+        let message;
+        while (message = this.buffer.pop()) {
+            callback(message);
+        }
+        Object.freeze(this.buffer);
+        this.callback = callback;
+    }
+
+}
+
+export function createWindowMessageConnection(serviceId: string, window: Window, sourceOrigin: string, targetOrigin = sourceOrigin): MessageConnection {
+    const reader = new WindowMessageReader(serviceId, sourceOrigin);
+    const writer = new WindowMessageWriter(serviceId, window, targetOrigin);
+    return createMessageConnection(reader, writer, new ConsoleLogger());
+}

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * Copyright (c) 2020 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.
  */
@@ -25,21 +25,30 @@ export namespace ErrorCodes {
     // 410 No User
     export const SETUP_REQUIRED = 410;
 
+    // 429 Too Many Requests
+    export const TOO_MANY_REQUESTS = 429;
+
     // 430 Repository not whitelisted (custom status code)
     export const REPOSITORY_NOT_WHITELISTED = 430;
 
     // 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;
 
     // 470 User Blocked (custom status code)
     export const USER_BLOCKED = 470;
 
-    // 471 User Blocked (custom status code)
+    // 471 User Deleted (custom status code)
     export const USER_DELETED = 471;
 
+    // 472 Terms Acceptance Required (custom status code)
+    export const USER_TERMS_ACCEPTANCE_REQUIRED = 472;
+
     // 480 Plan does not allow private repos
     export const PLAN_DOES_NOT_ALLOW_PRIVATE_REPOS = 480;
 
@@ -58,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 });
                 }
             })
         },