@gitpod/gitpod-protocol 0.1.5-update-ovsx.0 → 0.1.5-update-yarnlock.0

package/src/messaging/browser/window-connection.ts

@@ -1,20 +1,30 @@
-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';
+/**
+ * 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
+    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');
+    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();
     }
@@ -23,44 +33,50 @@ export class WindowMessageWriter extends AbstractMessageWriter implements Messag
         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);
+        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()) {
+        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 {
+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,94 @@
+/**
+ * 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";
+import { IClientCallMetrics, IGrpcCallMetricsLabels, IGrpcCallMetricsLabelsWithCode } from "../util/grpc";
+
+@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>;
+    readonly handledSecondsHistogram: prometheusClient.Histogram<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],
+        });
+        this.handledSecondsHistogram = new prometheusClient.Histogram({
+            name: "grpc_client_handling_seconds",
+            help: "Histogram of response latency (seconds) of the gRPC until it is finished by the application.",
+            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,
+        });
+    }
+
+    startHandleTimer(
+        labels: IGrpcCallMetricsLabelsWithCode,
+    ): (labels?: Partial<Record<string, string | number>> | undefined) => number {
+        return this.handledSecondsHistogram.startTimer({
+            grpc_service: labels.service,
+            grpc_method: labels.method,
+            grpc_type: labels.type,
+        });
+    }
+}

package/src/messaging/error.ts

@@ -1,12 +1,13 @@
 /**
- * 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.
+ * See License.AGPL.txt in the project root for license information.
  */
 
-
-
 export namespace ErrorCodes {
+    // 400 Unauthorized
+    export const BAD_REQUEST = 400;
+
     // 401 Unauthorized
     export const NOT_AUTHENTICATED = 401;
 
@@ -25,21 +26,45 @@ export namespace ErrorCodes {
     // 410 No User
     export const SETUP_REQUIRED = 410;
 
+    // 411 No User
+    export const NEEDS_VERIFICATION = 411;
+
+    // 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;
+    // 440 Prebuilds now always require a project (custom status code)
+    export const PROJECT_REQUIRED = 440;
 
     // 450 Payment error
     export const PAYMENT_ERROR = 450;
 
+    // 451 Out of credits
+    export const PAYMENT_SPENDING_LIMIT_REACHED = 451;
+
+    // 451 Error creating a subscription
+    export const SUBSCRIPTION_ERROR = 452;
+
+    // 455 Invalid cost center (custom status code)
+    export const INVALID_COST_CENTER = 455;
+
+    // 460 Context Parse Error (custom status code)
+    export const CONTEXT_PARSE_ERROR = 460;
+
+    // 461 Invalid gitpod yml (custom status code)
+    export const INVALID_GITPOD_YML = 461;
+
     // 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;
 
@@ -52,18 +77,34 @@ export namespace ErrorCodes {
     // 490 Too Many Running Workspace
     export const TOO_MANY_RUNNING_WORKSPACES = 490;
 
+    // 500 Internal Server Error
+    export const INTERNAL_SERVER_ERROR = 500;
+
     // 501 EE Feature
     export const EE_FEATURE = 501;
 
     // 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;
+
+    // 640 Headless logs are not available (yet)
+    export const HEADLESS_LOG_NOT_YET_AVAILABLE = 640;
+
+    // 650 Invalid Value
+    export const INVALID_VALUE = 650;
+
+    export function isUserError(code: number): boolean {
+        return code >= 400 && code < 500;
+    }
+}

package/src/messaging/handler.ts

@@ -7,9 +7,21 @@
 
 import { MessageConnection } from "vscode-jsonrpc";
 
-export const ConnectionHandler = Symbol('ConnectionHandler');
+export const ConnectionHandler = Symbol("ConnectionHandler");
 
 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

@@ -6,82 +6,35 @@
  */
 
 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 { log } from '../../util/logging';
+import { IWebSocket } from "vscode-ws-jsonrpc";
 
-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;
+export function toIWebSocket(ws: ws) {
     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 });
-                }
+        send: (content) => {
+            if (ws.readyState >= ws.CLOSING) {
+                // ws is already CLOSING/CLOSED, send() would just return an error.
                 return;
             }
-            webSocket.send(content, err => {
-                if (err) {
-                    log.error('Error in ws.send()', err, { ws });
-                }
-            })
+
+            // in general send-errors should trigger an 'error' event already, we just make sure it actually happens.
+            try {
+                ws.send(content, (err) => {
+                    if (!err) {
+                        return;
+                    }
+                    ws.emit("error", err);
+                });
+            } catch (err) {
+                ws.emit("error", err);
+            }
         },
-        onMessage: cb => webSocket.on('message', cb),
-        onError: cb => webSocket.on('error', cb),
-        onClose: cb => webSocket.on('close', cb),
+        onMessage: (cb) => ws.on("message", cb),
+        onError: (cb) => ws.on("error", cb),
+        onClose: (cb) => ws.on("close", cb),
         dispose: () => {
-            if (webSocket.readyState < ws.CLOSING) {
-                webSocket.close();
+            if (ws.readyState < ws.CLOSING) {
+                ws.close();
             }
-        }
+        },
     };
 }

package/src/messaging/proxy-factory.ts

@@ -8,8 +8,8 @@
 import { MessageConnection, ResponseError } from "vscode-jsonrpc";
 import { Event, Emitter } from "../util/event";
 import { Disposable } from "../util/disposable";
-import { ConnectionHandler } from './handler';
-import { log } from '../util/logging';
+import { ConnectionHandler } from "./handler";
+import { log } from "../util/logging";
 
 export type JsonRpcServer<Client> = Disposable & {
     /**
@@ -27,10 +27,7 @@ export interface JsonRpcConnectionEventEmitter {
 export type JsonRpcProxy<T> = T & JsonRpcConnectionEventEmitter;
 
 export class JsonRpcConnectionHandler<T extends object> implements ConnectionHandler {
-    constructor(
-        readonly path: string,
-        readonly targetFactory: (proxy: JsonRpcProxy<T>, request?: object) => any
-    ) { }
+    constructor(readonly path: string, readonly targetFactory: (proxy: JsonRpcProxy<T>, request?: object) => any) {}
 
     onConnection(connection: MessageConnection, request?: object): void {
         const factory = new JsonRpcProxyFactory<T>();
@@ -83,7 +80,6 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
  * @param <T> - The type of the object to expose to JSON-RPC.
  */
 export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
-
     protected readonly onDidOpenConnectionEmitter = new Emitter<void>();
     protected readonly onDidCloseConnectionEmitter = new Emitter<void>();
 
@@ -101,17 +97,21 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
     }
 
     protected waitForConnection(): void {
-        this.connectionPromise = new Promise(resolve =>
-            this.connectionPromiseResolve = resolve
-        );
-        this.connectionPromise.then(connection => {
-            connection.onClose(() =>
-                this.onDidCloseConnectionEmitter.fire(undefined)
-            );
-            this.onDidOpenConnectionEmitter.fire(undefined);
+        this.connectionPromise = new Promise((resolve) => (this.connectionPromiseResolve = resolve));
+        this.connectionPromise.then((connection) => {
+            connection.onClose(() => this.fireConnectionClosed());
+            this.fireConnectionOpened();
         });
     }
 
+    fireConnectionClosed() {
+        this.onDidCloseConnectionEmitter.fire(undefined);
+    }
+
+    fireConnectionOpened() {
+        this.onDidOpenConnectionEmitter.fire(undefined);
+    }
+
     /**
      * Connect a MessageConnection to the factory.
      *
@@ -158,7 +158,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);
+        }
     }
 
     /**
@@ -196,35 +198,34 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * @returns A callable that executes the JSON-RPC call.
      */
     get(target: T, p: PropertyKey, receiver: any): any {
-        if (p === 'setClient') {
+        if (p === "setClient") {
             return (client: any) => {
                 this.target = client;
             };
         }
-        if (p === 'onDidOpenConnection') {
+        if (p === "onDidOpenConnection") {
             return this.onDidOpenConnectionEmitter.event;
         }
-        if (p === 'onDidCloseConnection') {
+        if (p === "onDidCloseConnection") {
             return this.onDidCloseConnectionEmitter.event;
         }
         const isNotify = this.isNotification(p);
         return (...args: any[]) =>
-            this.connectionPromise.then(connection =>
-                new Promise((resolve, reject) => {
-                    try {
-                        if (isNotify) {
-                            connection.sendNotification(p.toString(), ...args);
-                            resolve();
-                        } else {
-                            const resultPromise = connection.sendRequest(p.toString(), ...args) as Promise<any>;
-                            resultPromise
-                                .catch((err: any) => reject(err))
-                                .then((result: any) => resolve(result));
+            this.connectionPromise.then(
+                (connection) =>
+                    new Promise((resolve, reject) => {
+                        try {
+                            if (isNotify) {
+                                connection.sendNotification(p.toString(), ...args);
+                                resolve(undefined);
+                            } else {
+                                const resultPromise = connection.sendRequest(p.toString(), ...args) as Promise<any>;
+                                resultPromise.catch((err: any) => reject(err)).then((result: any) => resolve(result));
+                            }
+                        } catch (err) {
+                            reject(err);
                         }
-                    } catch (err) {
-                        reject(err);
-                    }
-                })
+                    }),
             );
     }
 

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/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;
+}