@gitpod/gitpod-protocol 0.1.5-wth-test.80 → 0.1.5-yh-vmoptions-fork.1

package/src/installation-admin-protocol.ts

@@ -4,11 +4,11 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
 const InstallationAdminSettingsPrototype = {
-    sendTelemetry: true
-}
+    sendTelemetry: true,
+};
 
 export type InstallationAdminSettings = typeof InstallationAdminSettingsPrototype;
 
@@ -24,10 +24,10 @@ export interface InstallationAdmin {
 }
 
 export interface TelemetryData {
-    installationAdmin: InstallationAdmin
-    totalUsers: number
-    totalWorkspaces: number
-    totalInstances: number
+    installationAdmin: InstallationAdmin;
+    totalUsers: number;
+    totalWorkspaces: number;
+    totalInstances: number;
 }
 
 export namespace InstallationAdmin {
@@ -36,7 +36,7 @@ export namespace InstallationAdmin {
             id: uuidv4(),
             settings: {
                 ...InstallationAdminSettingsPrototype,
-            }
+            },
         };
     }
 }

package/src/license-protocol.ts

@@ -4,11 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
 export interface LicenseValidationResult {
-    valid: boolean
-    msg?: string
-    issue?: LicenseIssue
+    valid: boolean;
+    msg?: string;
+    issue?: LicenseIssue;
 }
 
 export type LicenseIssue = "seats-exhausted";
@@ -16,9 +15,15 @@ export type LicenseIssue = "seats-exhausted";
 export interface LicenseInfo {
     key: string;
     seats: number;
+    userCount?: number;
     valid: boolean;
     validUntil: string;
     plan?: string;
+    features?: string[];
+    enabledFeatures?: string[];
+    type?: string;
+    errorMsg?: string;
+    fallbackAllowed: boolean;
 }
 
 export interface GetLicenseInfoResult {
@@ -34,5 +39,6 @@ export enum LicenseFeature {
 export interface LicenseService {
     validateLicense(): Promise<LicenseValidationResult>;
     getLicenseInfo(): Promise<GetLicenseInfoResult>;
-    licenseIncludesFeature(feature: LicenseFeature): Promise<boolean>
-}
+    adminGetLicense(): Promise<LicenseInfo>;
+    licenseIncludesFeature(feature: LicenseFeature): Promise<boolean>;
+}

package/src/messaging/browser/connection.ts

@@ -11,7 +11,7 @@ import { AbstractMessageWriter } from "vscode-jsonrpc/lib/messageWriter";
 import { AbstractMessageReader } from "vscode-jsonrpc/lib/messageReader";
 import { JsonRpcProxyFactory, JsonRpcProxy } from "../proxy-factory";
 import { ConnectionEventHandler, ConnectionHandler } from "../handler";
-import ReconnectingWebSocket, { Event } from 'reconnecting-websocket';
+import ReconnectingWebSocket, { Event } from "reconnecting-websocket";
 
 export interface WebSocketOptions {
     onerror?: (event: Event) => void;
@@ -19,7 +19,6 @@ export interface WebSocketOptions {
 }
 
 export class WebSocketConnectionProvider {
-
     /**
      * Create a proxy object to remote interface of T type
      * over a web socket connection for the given path.
@@ -27,27 +26,33 @@ export class WebSocketConnectionProvider {
      * An optional target can be provided to handle
      * notifications and requests from a remote side.
      */
-    createProxy<T extends object>(path: string | Promise<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);
         const startListening = (path: string) => {
-            const socket = this.listen({
-                path,
-                onConnection: c => factory.listen(c),
-            }, {
-                onTransportDidClose: () => factory.fireConnectionClosed(),
-                onTransportDidOpen: () => factory.fireConnectionOpened(),
-            },
-                options
+            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)
+                options.onListening(socket as any as ReconnectingWebSocket);
             }
         };
 
         if (typeof path === "string") {
             startListening(path);
         } else {
-            path.then(path => startListening(path));
+            path.then((path) => startListening(path));
         }
         return factory.createProxy();
     }
@@ -62,20 +67,15 @@ export class WebSocketConnectionProvider {
         const logger = this.createLogger();
         if (options && options.onerror) {
             const onerror = options.onerror;
-            webSocket.addEventListener('error', (event) => {
+            webSocket.addEventListener("error", (event) => {
                 onerror(event);
             });
         } else {
-            webSocket.addEventListener('error', (error: Event) => {
+            webSocket.addEventListener("error", (error: Event) => {
                 logger.error(JSON.stringify(error));
             });
         }
-        doListen(
-            webSocket as any as ReconnectingWebSocket,
-            handler,
-            eventHandler,
-            logger,
-        );
+        doListen(webSocket as any as ReconnectingWebSocket, handler, eventHandler, logger);
         return webSocket;
     }
 
@@ -93,10 +93,9 @@ export class WebSocketConnectionProvider {
             reconnectionDelayGrowFactor: 1.3,
             maxRetries: Infinity,
             debug: false,
-            WebSocket: WebSocket
+            WebSocket: WebSocket,
         }) as any;
     }
-
 }
 
 // The following was extracted from vscode-ws-jsonrpc to make these changes:
@@ -104,7 +103,12 @@ export class WebSocketConnectionProvider {
 //  - 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) {
+function doListen(
+    resocket: ReconnectingWebSocket,
+    handler: ConnectionHandler,
+    eventHandler: ConnectionEventHandler,
+    logger: Logger,
+) {
     resocket.addEventListener("close", () => eventHandler.onTransportDidClose());
 
     let alreadyOpened = false;
@@ -169,7 +173,7 @@ class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
 
     protected flushBuffer() {
         if (this.buffer.length === 0) {
-            return
+            return;
         }
 
         const buffer = [...this.buffer];
@@ -186,26 +190,25 @@ class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
     }
 }
 
-
 /**
  * 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 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.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}`
+                    name: "" + code,
+                    message: `Error during socket reconnect: code = ${code}, reason = ${reason}`,
                 };
                 this.fireError(error);
             }
@@ -213,47 +216,42 @@ class NonClosingWebSocketMessageReader extends AbstractMessageReader {
         });
     }
     listen(callback: (message: any) => void) {
-        if (this.state === 'initial') {
-            this.state = 'listening';
+        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) {
+                } else if (event.error) {
                     this.fireError(event.error);
-                }
-                else {
+                } else {
                     this.fireClose();
                 }
             }
         }
     }
     readMessage(message: any) {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, { message });
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             const data = JSON.parse(message);
             this.callback(data);
         }
     }
     fireError(error: any) {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, { error });
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             super.fireError(error);
         }
     }
     fireClose() {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, {});
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             super.fireClose();
         }
-        this.state = 'closed';
+        this.state = "closed";
     }
 }

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

@@ -4,23 +4,27 @@
  * 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';
+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();
     }
@@ -29,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

@@ -4,94 +4,93 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { injectable } from 'inversify';
-import * as prometheusClient from 'prom-client';
+import { injectable } from "inversify";
+import * as prometheusClient from "prom-client";
 
-type GrpcMethodType = 'unary' | 'client_stream' | 'server_stream' | 'bidi_stream';
+type GrpcMethodType = "unary" | "client_stream" | "server_stream" | "bidi_stream";
 export interface IGrpcCallMetricsLabels {
-	service: string,
-	method: string,
-	type: GrpcMethodType,
+    service: string;
+    method: string;
+    type: GrpcMethodType;
 }
 
 export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
-	code: string
+    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;
+    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>;
 
-	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],
+        });
+    }
 
-	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,
+        });
+    }
 
-	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,
+        });
+    }
 
-	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,
+        });
+    }
 
-	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
-		});
-	}
+    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

@@ -4,9 +4,10 @@
  * 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;
 
@@ -61,6 +62,9 @@ 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;
 
@@ -81,4 +85,4 @@ export namespace ErrorCodes {
 
     // 640 Headless logs are not available (yet)
     export const HEADLESS_LOG_NOT_YET_AVAILABLE = 640;
-}
+}

package/src/messaging/handler.ts

@@ -7,7 +7,7 @@
 
 import { MessageConnection } from "vscode-jsonrpc";
 
-export const ConnectionHandler = Symbol('ConnectionHandler');
+export const ConnectionHandler = Symbol("ConnectionHandler");
 
 export interface ConnectionHandler {
     readonly path: string;
@@ -18,10 +18,10 @@ export interface ConnectionEventHandler {
     /**
      * Called when the transport underpinning the connection got closed
      */
-     onTransportDidClose(): void;
+    onTransportDidClose(): void;
 
-     /**
-      * Called when the transport underpinning the connection is (re-)opened
-      */
-     onTransportDidOpen(): void;
+    /**
+     * Called when the transport underpinning the connection is (re-)opened
+     */
+    onTransportDidOpen(): void;
 }

package/src/messaging/node/connection.ts

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