@gitpod/gitpod-protocol 0.1.5-main.648 → 0.1.5-main.6480

package/src/headless-workspace-log.ts

@@ -1,42 +1,40 @@
 /**
  * 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 enum HeadlessWorkspaceEventType {
     LogOutput = "log-output",
     FinishedSuccessfully = "finish-success",
     FinishedButFailed = "finish-fail",
     AbortedTimedOut = "aborted-timeout",
     Aborted = "aborted",
-    Started = "started"
+    Failed = "failed",
+    Started = "started",
 }
 export namespace HeadlessWorkspaceEventType {
     export function isRunning(t: HeadlessWorkspaceEventType) {
         return t === HeadlessWorkspaceEventType.LogOutput;
     }
     export function didFinish(t: HeadlessWorkspaceEventType) {
-        return t === HeadlessWorkspaceEventType.FinishedButFailed || t === HeadlessWorkspaceEventType.FinishedSuccessfully;
+        return (
+            t === HeadlessWorkspaceEventType.FinishedButFailed || t === HeadlessWorkspaceEventType.FinishedSuccessfully
+        );
     }
 }
 
-export interface HeadlessLogEvent {
+export interface HeadlessWorkspaceEvent {
     workspaceID: string;
     text: string;
     type: HeadlessWorkspaceEventType;
 }
 
-export enum TheiaHeadlessLogType {
-    TaskLogLabel = "workspaceTaskOutput",
-    TaskFailedLabel = "workspaceTaskFailed",
-    TaskSuccessfulLabel = "workspaceTaskDone"
+export interface HeadlessLogUrls {
+    // A map of id to URL
+    streams: { [streamID: string]: string };
 }
 
-export interface TheiaHeadlessLogMessage {
-    type: TheiaHeadlessLogType;
-    data?: string;
-    error?: string;
-    snapshotURL?: string;
-}
+/** cmp. @const HEADLESS_LOG_STREAM_STATUS_CODE_REGEX */
+export const HEADLESS_LOG_STREAM_STATUS_CODE = "X-LogStream-StatusCode";
+export const HEADLESS_LOG_STREAM_STATUS_CODE_REGEX = /X-LogStream-StatusCode: ([0-9]{3})/;

package/src/ide-frontend-service.ts

@@ -1,13 +1,13 @@
 /**
  * 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.
  */
 
 import { Event } from "./util/event";
 import { Disposable } from "./util/disposable";
 
-export type IDEFrontendState = 'init' | 'ready' | 'terminated';
+export type IDEFrontendState = "init" | "ready" | "terminated";
 
 export interface IDEFrontendService {
     readonly state: IDEFrontendState;
@@ -25,4 +25,4 @@ export interface IDEFrontendService {
      * confirmation dialogs for stopped workspaces.
      */
     start(): Disposable;
-}
+}

package/src/ide-protocol.ts

@@ -0,0 +1,147 @@
+/**
+ * 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;
+
+    /**
+     * Client specific IDE options.
+     */
+    clients?: { [id: string]: IDEClient };
+}
+
+export namespace IDEOptions {
+    export function asArray(options: IDEOptions): (IDEOption & { id: string })[] {
+        return Object.keys(options.options)
+            .map((id) => ({ ...options.options[id], id }))
+            .sort((a, b) => (a.orderKey || "").localeCompare(b.orderKey || ""));
+    }
+}
+
+export interface IDEClient {
+    /**
+     * The default desktop IDE when the user has not specified one.
+     */
+    defaultDesktopIDE?: string;
+
+    /**
+     * Desktop IDEs supported by the client.
+     */
+    desktopIDEs?: string[];
+
+    /**
+     * Steps to install the client on user machine.
+     */
+    installationSteps?: 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 rendered 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;
+
+    /**
+     * The latest image ref to the IDE image, this image ref always resolve to digest.
+     */
+    latestImage?: 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;
+
+    /**
+     * The plugin image ref for the IDE image, this image ref always resolve to digest.
+     */
+    pluginImage?: string;
+
+    /**
+     * The latest plugin image ref for the latest IDE image, this image ref always resolve to digest.
+     */
+    pluginLatestImage?: string;
+
+    /**
+     * ImageVersion the semantic version of the IDE image.
+     */
+    imageVersion?: string;
+
+    /**
+     * LatestImageVersion the semantic version of the latest IDE image.
+     */
+    latestImageVersion?: string;
+}

package/src/index.ts

@@ -1,16 +1,22 @@
 /**
  * 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 * from './protocol';
-export * from './gitpod-service';
-export * from './util/disposable';
-export * from './util/event';
-export * from './util/queue';
-export * from './license-protocol';
-export * from './workspace-instance';
-export * from './permission';
-export * from './admin-protocol';
-export * from './email-protocol';
+export * from "./protocol";
+export * from "./gitpod-service";
+export * from "./util/disposable";
+export * from "./util/event";
+export * from "./util/queue";
+export * from "./license-protocol";
+export * from "./workspace-instance";
+export * from "./permission";
+export * from "./admin-protocol";
+export * from "./headless-workspace-log";
+export * from "./context-url";
+export * from "./teams-projects-protocol";
+export * from "./snapshot-url";
+export * from "./oss-allowlist";
+export * from "./installation-admin-protocol";
+export * from "./webhook-event";

package/src/installation-admin-protocol.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2022 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 { v4 as uuidv4 } from "uuid";
+
+const InstallationAdminSettingsPrototype = {
+    sendTelemetry: true,
+    sendCustomerID: true,
+};
+
+export type InstallationAdminSettings = typeof InstallationAdminSettingsPrototype;
+
+export namespace InstallationAdminSettings {
+    export function fields(): (keyof InstallationAdminSettings)[] {
+        return Object.keys(InstallationAdminSettingsPrototype) as (keyof InstallationAdminSettings)[];
+    }
+}
+
+export interface InstallationAdmin {
+    id: string;
+    settings: InstallationAdminSettings;
+}
+
+export interface TelemetryData {
+    installationAdmin: InstallationAdmin;
+    totalUsers: number;
+    totalWorkspaces: number;
+    totalInstances: number;
+    licenseType: string;
+    customerID?: string;
+}
+
+export namespace InstallationAdmin {
+    export function createDefault(): InstallationAdmin {
+        return {
+            id: uuidv4(),
+            settings: {
+                ...InstallationAdminSettingsPrototype,
+            },
+        };
+    }
+}

package/src/license-protocol.ts

@@ -1,14 +1,13 @@
 /**
  * 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 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

@@ -5,17 +5,20 @@
  * 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 {
-
     /**
      * Create a proxy object to remote interface of T type
      * over a web socket connection for the given path.
@@ -23,57 +26,56 @@ 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) => {
-            this.listen({
+            const socket = this.listen(
+                {
                     path,
-                    onConnection: c => factory.listen(c)
+                    onConnection: (c) => factory.listen(c),
+                },
+                {
+                    onTransportDidClose: () => factory.fireConnectionClosed(),
+                    onTransportDidOpen: () => factory.fireConnectionOpened(),
                 },
-                options
+                options,
             );
+            if (options?.onListening) {
+                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();
     }
-    createProxy2<T extends object>(path: string, target?: object, options?: WebSocketOptions): { proxy: JsonRpcProxy<T>, webSocket: WebSocket } {
-        const factory = new JsonRpcProxyFactory<T>(target);
-        const webSocket = this.listen({
-            path,
-            onConnection: c => factory.listen(c)
-        }, options);
-        const proxy = factory.createProxy();
-        return { proxy, webSocket };
-    }
 
     /**
      * 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);
 
         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,
-            onConnection: connection => handler.onConnection(connection),
-            logger
-        });
+        doListen(webSocket as any as ReconnectingWebSocket, handler, eventHandler, logger);
         return webSocket;
     }
 
@@ -91,8 +93,165 @@ 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:
+//  - 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";
+    }
 }