@gitpod/gitpod-protocol 0.1.5-tweak-workspaceconfig-origin-docs-fork.0 → 0.1.5-update-yarnlock.0

package/src/encryption/key-provider.ts

@@ -1,22 +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.
  */
 
 import { injectable, inject } from "inversify";
 
 export interface KeyMetadata {
-    name: string,
-    version: number
+    name: string;
+    version: number;
 }
 
 export interface Key {
-    metadata: KeyMetadata,
-    material: Buffer
+    metadata: KeyMetadata;
+    material: Buffer;
 }
 
-export const KeyProvider = Symbol('KeyProvider');
+export const KeyProvider = Symbol("KeyProvider");
 export interface KeyProvider {
     getPrimaryKey(): Key;
     getKeyFor(metadata: KeyMetadata): Key;
@@ -24,24 +24,21 @@ export interface KeyProvider {
 
 export type KeyConfig = KeyMetadata & {
     /** base64 encoded */
-    material: string,
-    primary?: boolean
-}
+    material: string;
+    primary?: boolean;
+};
 
-export const KeyProviderConfig = Symbol('KeyProviderConfig');
+export const KeyProviderConfig = Symbol("KeyProviderConfig");
 export interface KeyProviderConfig {
-    keys: KeyConfig[]
+    keys: KeyConfig[];
 }
 
 @injectable()
 export class KeyProviderImpl implements KeyProvider {
-
     static loadKeyConfigFromJsonString(configStr: string): KeyConfig[] {
         const keys = (JSON.parse(configStr) || []) as KeyConfig[];
-        if (!Array.isArray(keys)
-            || keys.length < 0
-            || 1 !== keys.reduce((p, k) => k.primary ? p + 1 : p, 0)) {
-            throw new Error('Invalid key config!');
+        if (!Array.isArray(keys) || keys.length < 0 || 1 !== keys.reduce((p, k) => (k.primary ? p + 1 : p), 0)) {
+            throw new Error("Invalid key config!");
         }
         return keys;
     }
@@ -49,13 +46,13 @@ export class KeyProviderImpl implements KeyProvider {
     constructor(@inject(KeyProviderConfig) protected readonly config: KeyProviderConfig) {}
 
     protected get keys() {
-        return this.config.keys
+        return this.config.keys;
     }
 
     getPrimaryKey(): Key {
         const primaryKey = this.keys.find((key) => !!key.primary);
         if (!primaryKey) {
-            throw new Error('No primary encryption key found!');
+            throw new Error("No primary encryption key found!");
         }
         return this.configToKey(primaryKey);
     }
@@ -72,9 +69,9 @@ export class KeyProviderImpl implements KeyProvider {
         return {
             metadata: {
                 name: config.name,
-                version: config.version
+                version: config.version,
             },
-            material: new Buffer(config.material, 'base64')
+            material: Buffer.from(config.material, "base64"),
         };
     }
 }

package/src/env.ts

@@ -1,36 +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 { injectable } from "inversify";
 
-const legacyStagenameTranslation: { [key: string]: KubeStage } = {
-    "production": "production",
-    "staging": "prodcopy",
-    "devstaging": "dev",
-    "dev": "dev"
-}
-
-export function translateLegacyStagename(kubeStage: string): KubeStage {
-    const stage = legacyStagenameTranslation[kubeStage];
-    if (!stage) {
-        throw new Error(`Invalid KUBE_STAGE: ${kubeStage}`);
-    }
-
-    return stage;
-}
-
 @injectable()
-export abstract class AbstractComponentEnv {
-    readonly kubeStage: KubeStage = getEnvVarParsed('KUBE_STAGE', translateLegacyStagename);
-
-    readonly installationLongname: string = getEnvVar("GITPOD_INSTALLATION_LONGNAME")
-    readonly installationShortname: string = getEnvVar("GITPOD_INSTALLATION_SHORTNAME")
-}
-
-export type KubeStage = 'production' | 'prodcopy' | 'staging' | 'dev';
+export abstract class AbstractComponentEnv {}
 
 export function getEnvVar(name: string, defaultValue?: string): string {
     const value = process.env[name] || defaultValue;

package/src/experiments/always-default.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { Attributes, Client } from "./types";
+
+// AlwaysReturningDefaultValueClient is an implemention of an experiments.Client which performs no lookup/network operation
+// and always returns the default value for a given experimentName.
+// This client is used for non-SaaS version of Gitpod, in particular for self-hosted installations where external
+// network connections are not desirable or even possible.
+class AlwaysReturningDefaultValueClient implements Client {
+    getValueAsync<T>(experimentName: string, defaultValue: T, attributes: Attributes): Promise<T> {
+        return Promise.resolve(defaultValue);
+    }
+
+    dispose(): void {
+        // there is nothing to dispose, no-op.
+    }
+}
+
+export function newAlwaysReturningDefaultValueClient(): Client {
+    return new AlwaysReturningDefaultValueClient();
+}

package/src/experiments/configcat-server.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { Client } from "./types";
+import * as configcat from "configcat-node";
+import { LogLevel } from "configcat-common";
+import { ConfigCatClient } from "./configcat";
+import { newAlwaysReturningDefaultValueClient } from "./always-default";
+
+let client: Client | undefined;
+
+export type ConfigCatClientFactory = () => Client;
+export const ConfigCatClientFactory = Symbol("ConfigCatClientFactory");
+
+export function getExperimentsClientForBackend(): Client {
+    // We have already instantiated a client, we can just re-use it.
+    if (client !== undefined) {
+        return client;
+    }
+
+    // Retrieve SDK key from ENV Variable
+    const sdkKey = process.env.CONFIGCAT_SDK_KEY;
+
+    // Self-hosted installations do not set the ConfigCat SDK key, so always use a client which returns the default value.
+    if (sdkKey === undefined || sdkKey === "") {
+        client = newAlwaysReturningDefaultValueClient();
+        return client;
+    }
+
+    const configCatClient = configcat.createClient(sdkKey, {
+        pollIntervalSeconds: 3 * 60, // 3 minutes
+        requestTimeoutMs: 2000,
+        logger: configcat.createConsoleLogger(LogLevel.Error),
+        maxInitWaitTimeSeconds: 0,
+    });
+
+    client = new ConfigCatClient(configCatClient);
+    return client;
+}

package/src/experiments/configcat.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { Attributes, Client } from "./types";
+import { User as ConfigCatUser } from "configcat-common/lib/RolloutEvaluator";
+import { IConfigCatClient } from "configcat-common/lib/ConfigCatClient";
+import { User } from "../protocol";
+
+export const USER_ID_ATTRIBUTE = "user_id";
+export const PROJECT_ID_ATTRIBUTE = "project_id";
+export const TEAM_ID_ATTRIBUTE = "team_id";
+export const TEAM_NAME_ATTRIBUTE = "team_name";
+export const BILLING_TIER_ATTRIBUTE = "billing_tier";
+
+export class ConfigCatClient implements Client {
+    private client: IConfigCatClient;
+
+    constructor(cc: IConfigCatClient) {
+        this.client = cc;
+    }
+
+    getValueAsync<T>(experimentName: string, defaultValue: T, attributes: Attributes): Promise<T> {
+        return this.client.getValueAsync(experimentName, defaultValue, attributesToUser(attributes));
+    }
+
+    dispose(): void {
+        return this.client.dispose();
+    }
+}
+
+export function attributesToUser(attributes: Attributes): ConfigCatUser {
+    const userId = attributes.user?.id || "";
+    const email = User.is(attributes.user) ? User.getPrimaryEmail(attributes.user) : attributes.user?.email || "";
+
+    const custom: { [key: string]: string } = {};
+    if (userId) {
+        custom[USER_ID_ATTRIBUTE] = userId;
+    }
+    if (attributes.projectId) {
+        custom[PROJECT_ID_ATTRIBUTE] = attributes.projectId;
+    }
+    if (attributes.teamId) {
+        custom[TEAM_ID_ATTRIBUTE] = attributes.teamId;
+    }
+    if (attributes.teamName) {
+        custom[TEAM_NAME_ATTRIBUTE] = attributes.teamName;
+    }
+    if (attributes.billingTier) {
+        custom[BILLING_TIER_ATTRIBUTE] = attributes.billingTier;
+    }
+
+    return new ConfigCatUser(userId, email, "", custom);
+}

package/src/experiments/types.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { BillingTier, User } from "../protocol";
+
+export const Client = Symbol("Client");
+
+// Attributes define attributes which can be used to segment audiences.
+// Set the attributes which you want to use to group audiences into.
+export interface Attributes {
+    // user.id is mapped to ConfigCat's "identifier" + "custom.user_id"
+    user?: User | { id: string; email?: string };
+
+    // The BillingTier of this particular user
+    billingTier?: BillingTier;
+
+    // Currently selected Gitpod Project ID (mapped to "custom.project_id")
+    projectId?: string;
+
+    // Currently selected Gitpod Team ID (mapped to "custom.team_id")
+    teamId?: string;
+    // Currently selected Gitpod Team Name (mapped to "custom.team_name")
+    teamName?: string;
+}
+
+export interface Client {
+    getValueAsync<T>(experimentName: string, defaultValue: T, attributes: Attributes): Promise<T>;
+
+    // dispose will dispose of the client, no longer retrieving flags
+    dispose(): void;
+}

package/src/frontend-dashboard-service.ts

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2023 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 { WorkspaceInstancePhase } from "./workspace-instance";
+import { RemoteTrackMessage } from "./analytics";
+
+/**
+ * IDEFrontendDashboardService enables IDE related communications
+ * between the workspace to gitpod origins. Use it to communicate
+ * between IDE and dashboard iframes, never use
+ * `window.postMessage` directly.
+ *
+ * **Security Note**: never expose information about other workspaces
+ * or sensitive information for the current workspace, i.e. owner token.
+ */
+export namespace IDEFrontendDashboardService {
+    /**
+     * IClient is the client side which is using in supervisor frontend
+     */
+    export interface IClient {
+        trackEvent(msg: RemoteTrackMessage): void;
+        activeHeartbeat(): void;
+        setState(state: SetStateData): void;
+        openDesktopIDE(url: string): void;
+    }
+
+    /**
+     * IServer is the server side which is using in dashboard loading screen
+     */
+    export interface IServer {
+        // TODO(hw): to be removed after IDE deployed
+        sendStatusUpdate(status: Status): void;
+        // TODO(hw): end of todo
+        sendInfoUpdate(info: Info): void;
+        relocate(url: string): void;
+        openBrowserIDE(): void;
+    }
+
+    /**
+     * Info defined the information that `supervisor/frontend` requires.
+     */
+    export interface Info {
+        workspaceID: string;
+        loggedUserId: string;
+
+        instanceId?: string;
+        ideUrl?: string;
+        statusPhase?: WorkspaceInstancePhase;
+
+        workspaceDescription: string;
+        workspaceType: string;
+        credentialsToken: string;
+    }
+
+    // TODO(hw): to be removed after IDE deployed
+    export type Status = Info;
+    // TODO(hw): end of todo
+
+    export interface SetStateData {
+        ideFrontendFailureCause?: string;
+        desktopIDE?: {
+            clientID: string;
+            link: string;
+            label?: string;
+        };
+    }
+
+    // TODO(hw): to be removed after IDE deployed
+    export interface StatusUpdateEventData {
+        // protocol version
+        version?: number;
+        type: "ide-status-update";
+        status: Status;
+    }
+    // TODO(hw): end of todo
+
+    export interface InfoUpdateEventData {
+        // protocol version
+        version?: number;
+        type: "ide-info-update";
+        info: Info;
+    }
+
+    export interface HeartbeatEventData {
+        type: "ide-heartbeat";
+    }
+
+    export interface TrackEventData {
+        type: "ide-track-event";
+        msg: RemoteTrackMessage;
+    }
+
+    export interface RelocateEventData {
+        type: "ide-relocate";
+        url: string;
+    }
+
+    export interface SetStateEventData {
+        type: "ide-set-state";
+        state: SetStateData;
+    }
+
+    export interface OpenBrowserIDE {
+        type: "ide-open-browser";
+    }
+
+    export interface OpenDesktopIDE {
+        type: "ide-open-desktop";
+        url: string;
+    }
+
+    // TODO(hw): to be removed after IDE deployed
+    export function isStatusUpdateEventData(obj: any): obj is StatusUpdateEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-status-update";
+    }
+    // TODO(hw): end of todo
+
+    export function isInfoUpdateEventData(obj: any): obj is InfoUpdateEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-info-update";
+    }
+
+    export function isHeartbeatEventData(obj: any): obj is HeartbeatEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-heartbeat";
+    }
+
+    export function isTrackEventData(obj: any): obj is TrackEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-track-event";
+    }
+
+    export function isRelocateEventData(obj: any): obj is RelocateEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-relocate";
+    }
+
+    export function isSetStateEventData(obj: any): obj is SetStateEventData {
+        return obj != null && typeof obj === "object" && obj.type === "ide-set-state";
+    }
+
+    export function isOpenBrowserIDE(obj: any): obj is OpenBrowserIDE {
+        return obj != null && typeof obj === "object" && obj.type === "ide-open-browser";
+    }
+
+    export function isOpenDesktopIDE(obj: any): obj is OpenDesktopIDE {
+        return obj != null && typeof obj === "object" && obj.type === "ide-open-desktop";
+    }
+}

package/src/gitpod-file-parser.spec.ts

@@ -1,22 +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.
  */
 
-import { suite, test } from "mocha-typescript"
-import * as chai from "chai"
+import { suite, test } from "mocha-typescript";
+import * as chai from "chai";
 
-import { WorkspaceConfig } from './protocol';
-import { GitpodFileParser } from './gitpod-file-parser';
+import { WorkspaceConfig } from "./protocol";
+import { GitpodFileParser } from "./gitpod-file-parser";
 
-const expect = chai.expect
+const expect = chai.expect;
 
 const DEFAULT_IMAGE = "default-image";
 const DEFAULT_CONFIG = <WorkspaceConfig>{ image: DEFAULT_IMAGE };
 
-@suite class TestGitpodFileParser {
-
+@suite
+class TestGitpodFileParser {
     protected parser: GitpodFileParser;
 
     public before() {
@@ -24,107 +24,102 @@ const DEFAULT_CONFIG = <WorkspaceConfig>{ image: DEFAULT_IMAGE };
     }
 
     @test public testOnlyOnePort() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555`;
+        const content = `ports:\n` + `  - port: 5555`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testPortRange() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555\n` +
-            `  - port: 3000-3999`; // should be filtered out by default
+        const content = `ports:\n` + `  - port: 5555\n` + `  - port: 3000-3999`; // should be filtered out by default
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testPortRangeAccepted() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555\n` +
-            `  - port: 3000-3999`; // should be included if explicitly supported
+        const content = `ports:\n` + `  - port: 5555\n` + `  - port: 3000-3999`; // should be included if explicitly supported
 
         const result = this.parser.parse(content, { acceptPortRanges: true }, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }, {
-                port: '3000-3999'
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+                {
+                    port: "3000-3999",
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testSimpleTask() {
-        const content =
-            `tasks:\n` +
-            `  - command: yarn`;
+        const content = `tasks:\n` + `  - command: yarn`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            tasks: [{
-                command: "yarn"
-            }],
-            image: DEFAULT_IMAGE
+            tasks: [
+                {
+                    command: "yarn",
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testSimpleImage() {
         const imageName = "my-test-org/my-test-image:some-tag";
-        const content =
-            `image: "${imageName}"\n`;
+        const content = `image: "${imageName}"\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
-            image: imageName
+            image: imageName,
         });
     }
 
     @test public testComplexImageWithoutContext() {
-        const dockerFileName = 'Dockerfile';
-        const content =
-            `image:\n  file: ${dockerFileName}\n`;
+        const dockerFileName = "Dockerfile";
+        const content = `image:\n  file: ${dockerFileName}\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
             image: {
-                file: dockerFileName
-            }
+                file: dockerFileName,
+            },
         });
     }
 
     @test public testComplexImageWithContext() {
-        const dockerFileName = 'Dockerfile';
-        const dockerContext = 'docker';
-        const content =
-            `image:\n  file: ${dockerFileName}\n  context: ${dockerContext}\n`;
+        const dockerFileName = "Dockerfile";
+        const dockerContext = "docker";
+        const content = `image:\n  file: ${dockerFileName}\n  context: ${dockerContext}\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
             image: {
                 file: dockerFileName,
-                context: dockerContext
-            }
+                context: dockerContext,
+            },
         });
     }
 
     @test public testGitconfig() {
-        const content =
-`
+        const content = `
 gitConfig:
     core.autocrlf: input
 `;
@@ -132,20 +127,19 @@ gitConfig:
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
             gitConfig: {
-                "core.autocrlf": "input"
+                "core.autocrlf": "input",
             },
-            image: DEFAULT_IMAGE
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testBrokenConfig() {
-        const content =
-            `image: 42\n`;
+        const content = `image: 42\n`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            image: DEFAULT_IMAGE
+            image: DEFAULT_IMAGE,
         });
     }
 }
-module.exports = new TestGitpodFileParser()   // Only to circumvent no usage warning :-/
+module.exports = new TestGitpodFileParser(); // Only to circumvent no usage warning :-/