@gitpod/gitpod-protocol 0.1.5-to-code-reading.1 → 0.1.5-to-monitor-delete.18

package/src/context-url.spec.ts

@@ -4,36 +4,64 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as chai from 'chai';
-import { suite, test } from 'mocha-typescript';
-import { ContextURL } from './context-url';
+import * as chai from "chai";
+import { suite, test } from "mocha-typescript";
+import { Workspace } from ".";
+import { ContextURL } from "./context-url";
 const expect = chai.expect;
 
+type WsContextUrl = Pick<Workspace, "context" | "contextURL">;
+
 @suite
 export class ContextUrlTest {
-
     @test public parseContextUrl_withEnvVar() {
-        const actual = ContextURL.parseToURL("passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo");
+        const actual = ContextURL.getNormalizedURL({
+            contextURL: "passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo",
+            context: {},
+        } as WsContextUrl);
         expect(actual?.host).to.equal("github.com");
         expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
     }
 
     @test public parseContextUrl_withEnvVar_withoutSchema() {
-        const actual = ContextURL.parseToURL("passedin=test%20value/github.com/gitpod-io/gitpod-test-repo");
+        const actual = ContextURL.getNormalizedURL({
+            contextURL: "passedin=test%20value/github.com/gitpod-io/gitpod-test-repo",
+            context: {},
+        } as WsContextUrl);
         expect(actual?.host).to.equal("github.com");
         expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
     }
 
+    @test public parseContextUrl_withEnvVar_sshUrl() {
+        const actual = ContextURL.getNormalizedURL({
+            contextURL: "passedin=test%20value/git@github.com:gitpod-io/gitpod-test-repo.git",
+            context: {},
+        } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo.git");
+    }
+
     @test public parseContextUrl_withPrebuild() {
-        const actual = ContextURL.parseToURL("prebuild/https://github.com/gitpod-io/gitpod-test-repo");
+        const actual = ContextURL.getNormalizedURL({
+            contextURL: "prebuild/https://github.com/gitpod-io/gitpod-test-repo",
+            context: {},
+        } as WsContextUrl);
         expect(actual?.host).to.equal("github.com");
         expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
     }
 
     @test public parseContextUrl_withPrebuild_withoutSchema() {
-        const actual = ContextURL.parseToURL("prebuild/github.com/gitpod-io/gitpod-test-repo");
+        const actual = ContextURL.getNormalizedURL({
+            contextURL: "prebuild/github.com/gitpod-io/gitpod-test-repo",
+            context: {},
+        } as WsContextUrl);
         expect(actual?.host).to.equal("github.com");
         expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
     }
+
+    @test public parseContextUrl_badUrl() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "[Object object]", context: {} } as WsContextUrl);
+        expect(actual).to.be.undefined;
+    }
 }
-module.exports = new ContextUrlTest()
+module.exports = new ContextUrlTest();

package/src/context-url.ts

@@ -4,48 +4,106 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
+import { Workspace } from ".";
+
+/**
+ * The whole point of these methods is to overcome inconsistencies in our data model.
+ * Ideally we remove it at some point once we fixed our model, as it:
+ *  - duplicates logic
+ *  - but additional burden on clients (using this, copying this to other languages!)
+ *
+ * TODO(gpl) See if we can get this into `server` code to remove the burden from clients
+ */
 export namespace ContextURL {
-  export const INCREMENTAL_PREBUILD_PREFIX = "incremental-prebuild";
-  export const PREBUILD_PREFIX = "prebuild";
-  export const IMAGEBUILD_PREFIX = "imagebuild";
-
-  /**
-   * The field "contextUrl" might contain prefixes like:
-   *  - envvar1=value1/...
-   *  - prebuild/...
-   * This is the analogon to the (Prefix)ContextParser structure in "server".
-   */
-  export function parseToURL(contextUrl: string | undefined): URL | undefined {
-    if (contextUrl === undefined) {
-      return undefined;
+    export const INCREMENTAL_PREBUILD_PREFIX = "incremental-prebuild";
+    export const PREBUILD_PREFIX = "prebuild";
+    export const IMAGEBUILD_PREFIX = "imagebuild";
+    export const SNAPSHOT_PREFIX = "snapshot";
+    export const REFERRER_PREFIX = "referrer:";
+
+    /**
+     * This function will (try to) return the HTTP(S) URL of the context the user originally created this workspace on.
+     * Especially it will not contain any modifiers or be of different scheme than HTTP(S).
+     *
+     * Use this function if you need to provided a _working_ URL to the original context.
+     * @param ws
+     * @returns
+     */
+    export function getNormalizedURL(ws: Pick<Workspace, "context" | "contextURL"> | undefined): URL | undefined {
+        const normalized = normalize(ws);
+        if (!normalized) {
+            return undefined;
+        }
+
+        try {
+            return new URL(normalized);
+        } catch (err) {
+            console.debug(`unable to parse URL from normalized contextURL: '${normalized}'`);
+        }
+        return undefined;
     }
 
-    const segments = contextUrl.split("/");
-    if (segments.length === 1) {
-      return new URL(segments[0]);  // this might be something, we just try
+    function normalize(ws: Pick<Workspace, "context" | "contextURL"> | undefined): string | undefined {
+        if (!ws) {
+            return undefined;
+        }
+        if (ws.context.normalizedContextURL) {
+            return ws.context.normalizedContextURL;
+        }
+
+        // fallback: we do not yet set normalizedContextURL on all workspaces, yet, let alone older existing workspaces
+        let fallback: string | undefined = undefined;
+        try {
+            fallback = removePrefixes(ws.contextURL);
+        } catch (err) {
+            console.error(`unable to remove prefixes from contextURL: '${ws.contextURL}'`, err);
+        }
+        return fallback;
     }
 
-    const segmentsToURL = (offset: number): URL => {
-      let rest = segments.slice(offset).join("/");
-      if (!rest.startsWith("http")) {
-        rest = 'https://' + rest;
-      }
-      return new URL(rest);
-    };
+    /**
+     * The field "contextUrl" might contain prefixes like:
+     *  - envvar1=value1/...
+     *  - prebuild/...
+     * This is the analogon to the (Prefix)ContextParser structure in "server".
+     */
+    function removePrefixes(contextUrl: string | undefined): string | undefined {
+        if (contextUrl === undefined) {
+            return undefined;
+        }
 
+        const segments = contextUrl.split("/");
+        if (segments.length === 1) {
+            return segments[0]; // this might be something, we just try
+        }
 
-    const firstSegment = segments[0];
-    if (firstSegment === PREBUILD_PREFIX ||
-        firstSegment === INCREMENTAL_PREBUILD_PREFIX ||
-        firstSegment === IMAGEBUILD_PREFIX) {
-      return segmentsToURL(1);
-    }
+        const segmentsToURL = (offset: number): string => {
+            let rest = segments.slice(offset).join("/");
+            if (/^git@[^:\/]+:/.test(rest)) {
+                rest = rest.replace(/^git@([^:\/]+):/, "https://$1/");
+            }
+            if (!rest.startsWith("http")) {
+                rest = "https://" + rest;
+            }
+            return rest;
+        };
 
-    // check for env vars
-    if (firstSegment.indexOf("=") !== -1) {
-      return segmentsToURL(1);
-    }
+        const firstSegment = segments[0];
+        if (
+            firstSegment === PREBUILD_PREFIX ||
+            firstSegment === INCREMENTAL_PREBUILD_PREFIX ||
+            firstSegment === IMAGEBUILD_PREFIX ||
+            firstSegment === SNAPSHOT_PREFIX ||
+            firstSegment.startsWith(REFERRER_PREFIX)
+        ) {
+            return segmentsToURL(1);
+        }
 
-    return segmentsToURL(0);
-  }
-}
+        // check for env vars
+        if (firstSegment.indexOf("=") !== -1) {
+            return segmentsToURL(1);
+        }
+
+        return segmentsToURL(0);
+    }
+}

package/src/encryption/container-module.ts

@@ -19,10 +19,9 @@ import { EncryptionService, EncryptionServiceImpl } from "./encryption-service";
  *      };
  *  }).inSingletonScope();
  */
-export const encryptionModule: interfaces.ContainerModuleCallBack = bind => {
-
+export const encryptionModule: interfaces.ContainerModuleCallBack = (bind) => {
     bind(KeyProvider).to(KeyProviderImpl).inSingletonScope();
 
     bind(EncryptionEngine).to(EncryptionEngineImpl).inSingletonScope();
     bind(EncryptionService).to(EncryptionServiceImpl).inSingletonScope();
-};
+};

package/src/encryption/encryption-engine.spec.ts

@@ -5,25 +5,26 @@
  */
 
 import { suite, test } from "mocha-typescript";
-import * as chai from 'chai';
-import * as path from 'path';
+import * as chai from "chai";
+import * as path from "path";
 import * as fs from "fs";
 
 import { EncryptionEngineImpl } from "./encryption-engine";
 
 const expect = chai.expect;
 
-@suite class TestEncryptionEngineImpl {
+@suite
+class TestEncryptionEngineImpl {
     // Created with openssl rand -rand /dev/urandom -out key -base64 32
-    protected get testkey () {
-        const keyFilePath = path.resolve(__dirname, '../../test/fixtures/encryption/testkey');
+    protected get testkey() {
+        const keyFilePath = path.resolve(__dirname, "../../test/fixtures/encryption/testkey");
         const keyBuffer = fs.readFileSync(keyFilePath);
         return keyBuffer.toString().trim();
-    };
+    }
 
     @test basicSymmetry() {
         const plaintext = "12345678901234567890";
-        const key = new Buffer(this.testkey, 'base64');
+        const key = Buffer.from(this.testkey, "base64");
 
         const cut = new EncryptionEngineImpl();
         const encryptedData = cut.encrypt(plaintext, key);
@@ -33,4 +34,4 @@ const expect = chai.expect;
         expect(decryptedPlaintext).equals(plaintext);
     }
 }
-export const t = new TestEncryptionEngineImpl();
+export const t = new TestEncryptionEngineImpl();

package/src/encryption/encryption-engine.ts

@@ -4,20 +4,20 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as crypto from 'crypto';
-import { injectable } from 'inversify';
+import * as crypto from "crypto";
+import { injectable } from "inversify";
 
 export interface KeyParams {
-    iv: string
+    iv: string;
 }
 
 export interface EncryptedData {
     /** utf8 encoded string */
-    data: string,
-    keyParams: KeyParams
+    data: string;
+    keyParams: KeyParams;
 }
 
-export const EncryptionEngine = Symbol('EncryptionEngine');
+export const EncryptionEngine = Symbol("EncryptionEngine");
 export interface EncryptionEngine {
     /**
      * @param data utf8 encoded string
@@ -32,28 +32,32 @@ export interface EncryptionEngine {
  * - no salt, as we pass in a real key (no salting needed to turn a password into a key)
  * The implementation closely follows the exampes in https://nodejs.org/api/crypto.html.
  */
- @injectable()
+@injectable()
 export class EncryptionEngineImpl {
-    readonly algorithm = 'aes-256-cbc';
-    readonly enc = 'base64';
+    readonly algorithm = "aes-256-cbc";
+    readonly enc = "base64";
 
     encrypt(data: string, key: Buffer): EncryptedData {
         const iv = crypto.randomBytes(16);
         const cipher = crypto.createCipheriv(this.algorithm, key, iv);
-        const encrypted = cipher.update(new Buffer(data, 'utf8'));
+        const encrypted = cipher.update(Buffer.from(data, "utf8"));
         const finalEncrypted = Buffer.concat([encrypted, cipher.final()]);
         return {
             data: finalEncrypted.toString(this.enc),
             keyParams: {
-                iv: iv.toString(this.enc)
-            }
+                iv: iv.toString(this.enc),
+            },
         };
     }
 
     decrypt(encryptedData: EncryptedData, key: Buffer): string {
-        const decipher = crypto.createDecipheriv(this.algorithm, key, new Buffer(encryptedData.keyParams.iv, this.enc));
-        let decrypted = decipher.update(new Buffer(encryptedData.data, this.enc));
+        const decipher = crypto.createDecipheriv(
+            this.algorithm,
+            key,
+            Buffer.from(encryptedData.keyParams.iv, this.enc),
+        );
+        let decrypted = decipher.update(Buffer.from(encryptedData.data, this.enc));
         const finalDecrypted = Buffer.concat([decrypted, decipher.final()]);
-        return finalDecrypted.toString('utf8');
+        return finalDecrypted.toString("utf8");
     }
-}
+}

package/src/encryption/encryption-service.ts

@@ -9,12 +9,11 @@ import { injectable, inject } from "inversify";
 import { EncryptedData, EncryptionEngine } from "./encryption-engine";
 import { KeyProvider, KeyMetadata } from "./key-provider";
 
-
 export interface Encrypted<_T> extends EncryptedData {
-    keyMetadata: KeyMetadata
+    keyMetadata: KeyMetadata;
 }
 
-export const EncryptionService = Symbol('EncryptionService');
+export const EncryptionService = Symbol("EncryptionService");
 export interface EncryptionService {
     encrypt<T>(data: T): Encrypted<T>;
     decrypt<T>(encrypted: Encrypted<T>): T;
@@ -32,7 +31,7 @@ export class EncryptionServiceImpl implements EncryptionService {
         const encryptedData = this.engine.encrypt(dataStr, key.material);
         return {
             ...encryptedData,
-            keyMetadata: key.metadata
+            keyMetadata: key.metadata,
         };
     }
 
@@ -49,4 +48,4 @@ export class EncryptionServiceImpl implements EncryptionService {
     protected deserialize<T>(data: string): T {
         return JSON.parse(data) as T;
     }
-}
+}

package/src/encryption/key-provider.ts

@@ -7,16 +7,16 @@
 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

@@ -6,32 +6,10 @@
 
 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 function getEnvVar(name: string, defaultValue?: string): string {
     const value = process.env[name] || defaultValue;
     if (!value) {

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,41 @@
+/**
+ * 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
+        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;
+}