@gitpod/gitpod-protocol 0.1.5-wth-argo.0 → 0.1.5-yh-vmoptions-fork.1

package/src/snapshot-url.spec.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { suite, test } from "mocha-typescript";
+import * as chai from "chai";
+import { SnapshotUrl } from ".";
+
+const expect = chai.expect;
+
+@suite
+class TestSnapshotUrlParser {
+    @test public testPositive() {
+        const actual = SnapshotUrl.parse(
+            "workspaces/c362d434-6faa-4ce0-9ad4-91b4a87c4abe/3f0556f7-4afa-11e9-98d5-52f8983b9279.tar@gitpod-prodcopy-user-e1e28f18-0354-4a5d-b6b4-8879a2ff73fd",
+        );
+
+        expect(actual).to.deep.equal(<SnapshotUrl>{
+            bucketId: "gitpod-prodcopy-user-e1e28f18-0354-4a5d-b6b4-8879a2ff73fd",
+            filename: "3f0556f7-4afa-11e9-98d5-52f8983b9279.tar",
+            fullPath: "workspaces/c362d434-6faa-4ce0-9ad4-91b4a87c4abe/3f0556f7-4afa-11e9-98d5-52f8983b9279.tar",
+        });
+    }
+}
+module.exports = new TestSnapshotUrlParser(); // Only to circumvent no usage warning :-/

package/src/snapshot-url.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 SnapshotUrl {
+    bucketId: string;
+    fullPath: string;
+    filename: string;
+}
+export namespace SnapshotUrl {
+    export function parse(url: string): SnapshotUrl {
+        const parts = url.split("@");
+        if (parts.length !== 2) {
+            throw new Error(`cannot parse snapshot URL: ${url}`);
+        }
+        const [fullPath, bucketId] = parts;
+
+        const pathParts = fullPath.split("/");
+        if (pathParts.length < 1) {
+            throw new Error(`cannot parse snapshot URL: ${url}`);
+        }
+        const filename = pathParts[pathParts.length - 1];
+        return { bucketId, fullPath, filename };
+    }
+}

package/src/team-subscription-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.
+ */
+
+import { v4 as uuidv4 } from "uuid";
+import { Subscription } from "./accounting-protocol";
+
+export interface TeamSubscription {
+    id: string;
+    userId: string;
+    planId: string;
+    startDate: string;
+    endDate?: string;
+    quantity: number;
+    /** The Chargebee subscription id */
+    paymentReference: string;
+    cancellationDate?: string;
+    deleted?: boolean;
+    /** If this flag is set slots are not eligibile for clusters with "more-resources" - even if their plan might be */
+    excludeFromMoreResources: boolean;
+}
+
+export namespace TeamSubscription {
+    export const create = (ts: Omit<TeamSubscription, "id">): TeamSubscription => {
+        const withId = ts as TeamSubscription;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const isActive = (ts: TeamSubscription, date: string): boolean => {
+        return ts.startDate <= date && (ts.endDate === undefined || date < ts.endDate);
+    };
+}
+
+export interface TeamSubscription2 {
+    id: string;
+    teamId: string;
+    planId: string;
+    startDate: string;
+    endDate?: string;
+    quantity: number;
+    /** The Chargebee subscription id */
+    paymentReference: string;
+    cancellationDate?: string;
+    excludeFromMoreResources: boolean;
+}
+
+export namespace TeamSubscription2 {
+    export const create = (ts2: Omit<TeamSubscription2, "id">): TeamSubscription2 => {
+        const withId = ts2 as TeamSubscription2;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
+        return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
+    };
+}
+
+/**
+ * A slot represents one unit of a TeamSubscription that gets assigned to one user at a time
+ */
+export interface TeamSubscriptionSlot {
+    id: string;
+    teamSubscriptionId: string;
+    assigneeId?: string;
+    assigneeIdentifier?: AssigneeIdentifier;
+    subscriptionId?: string;
+    cancellationDate?: string;
+}
+export type TeamSubscriptionSlotDeactivated = TeamSubscriptionSlot & {
+    assigneeId: string;
+    assigneeIdentifier: AssigneeIdentifier;
+};
+export type TeamSubscriptionSlotAssigned = TeamSubscriptionSlot &
+    TeamSubscriptionSlotDeactivated & { subscriptionId: string };
+
+export type TeamSubscriptionSlotState = "unassigned" | "assigned" | "deactivated" | "cancelled";
+
+export namespace TeamSubscriptionSlot {
+    export const create = (ts: Omit<TeamSubscriptionSlot, "id">): TeamSubscriptionSlot => {
+        const withId = ts as TeamSubscriptionSlot;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const assign = (
+        slot: TeamSubscriptionSlot,
+        assigneeId: string,
+        subscriptionId: string,
+        assigneeIdentifier: AssigneeIdentifier,
+    ) => {
+        slot.assigneeId = assigneeId;
+        slot.subscriptionId = subscriptionId;
+        slot.assigneeIdentifier = assigneeIdentifier;
+    };
+    export const deactivate = (slot: TeamSubscriptionSlot, cancellationDate: string) => {
+        slot.subscriptionId = undefined;
+        slot.cancellationDate = cancellationDate;
+    };
+    export const reactivate = (slot: TeamSubscriptionSlot, subscriptionId?: string) => {
+        slot.subscriptionId = subscriptionId;
+        slot.cancellationDate = undefined;
+    };
+    export const status = (slot: TeamSubscriptionSlot, now: string): TeamSubscriptionSlotState => {
+        if (slot.cancellationDate) {
+            if (slot.cancellationDate < now) {
+                return "cancelled";
+            } else {
+                return "deactivated";
+            }
+        } else {
+            if (slot.subscriptionId) {
+                return "assigned";
+            } else {
+                return "unassigned";
+            }
+        }
+    };
+    export const isActive = (slot: TeamSubscriptionSlot): boolean => {
+        return !slot.cancellationDate;
+    };
+}
+
+/**
+ * The mapping between a TeamSubscription and a resulting Subscription, resolved
+ */
+export interface TeamSubscriptionSlotResolved {
+    id: string;
+    teamSubscription: TeamSubscription;
+    state: TeamSubscriptionSlotState;
+    assigneeId?: string;
+    assigneeIdentifier?: AssigneeIdentifier;
+    subscription?: Subscription;
+    cancellationDate?: string;
+    hoursLeft?: number;
+}
+
+/**
+ * Contains the data structure that the assigner used to identify the assignee.
+ */
+export type AssigneeIdentifier = AssigneeIdentityIdentifier;
+export interface AssigneeIdentityIdentifier {
+    identity: {
+        authHost: string;
+        authName: string;
+    };
+}

package/src/teams-projects-protocol.ts

@@ -0,0 +1,153 @@
+/**
+ * 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 { PrebuiltWorkspaceState } from "./protocol";
+import { v4 as uuidv4 } from "uuid";
+import { DeepPartial } from "./util/deep-partial";
+
+export interface ProjectConfig {
+    ".gitpod.yml": string;
+}
+
+export interface ProjectSettings {
+    useIncrementalPrebuilds?: boolean;
+    usePersistentVolumeClaim?: boolean;
+}
+
+export interface Project {
+    id: string;
+    name: string;
+    slug?: string;
+    cloneUrl: string;
+    teamId?: string;
+    userId?: string;
+    appInstallationId: string;
+    config?: ProjectConfig;
+    settings?: ProjectSettings;
+    creationTime: string;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+    markedDeleted?: boolean;
+}
+
+export namespace Project {
+    export const create = (project: Omit<Project, "id" | "creationTime">): Project => {
+        return {
+            ...project,
+            id: uuidv4(),
+            creationTime: new Date().toISOString(),
+        };
+    };
+
+    export interface Overview {
+        branches: BranchDetails[];
+    }
+
+    export namespace Overview {
+        export function is(data?: any): data is Project.Overview {
+            return Array.isArray(data?.branches);
+        }
+    }
+
+    export interface BranchDetails {
+        name: string;
+        url: string;
+        isDefault: boolean;
+
+        // Latest commit
+        changeTitle: string;
+        changeDate?: string;
+        changeAuthor?: string;
+        changeAuthorAvatar?: string;
+        changePR?: string;
+        changeUrl?: string;
+        changeHash: string;
+    }
+}
+
+export type PartialProject = DeepPartial<Project> & Pick<Project, "id">;
+
+export interface ProjectUsage {
+    lastWebhookReceived: string;
+    lastWorkspaceStart: string;
+}
+
+export interface PrebuildWithStatus {
+    info: PrebuildInfo;
+    status: PrebuiltWorkspaceState;
+    error?: string;
+}
+
+export interface PrebuildInfo {
+    id: string;
+    buildWorkspaceId: string;
+    basedOnPrebuildId?: string;
+
+    teamId?: string;
+    userId?: string;
+
+    projectId: string;
+    projectName: string;
+
+    cloneUrl: string;
+    branch: string;
+
+    startedAt: string;
+    startedBy: string;
+    startedByAvatar?: string;
+
+    changeTitle: string;
+    changeDate: string;
+    changeAuthor: string;
+    changeAuthorAvatar?: string;
+    changePR?: string;
+    changeUrl?: string;
+    changeHash: string;
+}
+export namespace PrebuildInfo {
+    export function is(data?: any): data is PrebuildInfo {
+        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every((p) => p in data);
+    }
+}
+
+export interface StartPrebuildResult {
+    prebuildId: string;
+    wsid: string;
+    done: boolean;
+}
+
+export interface Team {
+    id: string;
+    name: string;
+    slug: string;
+    creationTime: string;
+    markedDeleted?: boolean;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}
+
+export type TeamMemberRole = "owner" | "member";
+
+export interface TeamMemberInfo {
+    userId: string;
+    fullName?: string;
+    primaryEmail?: string;
+    avatarUrl?: string;
+    role: TeamMemberRole;
+    memberSince: string;
+}
+
+export interface TeamMembershipInvite {
+    id: string;
+    teamId: string;
+    role: TeamMemberRole;
+    creationTime: string;
+    invalidationTime: string;
+    invitedEmail?: string;
+
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}

package/src/typings/globals.ts

@@ -6,7 +6,7 @@
 
 interface Window {
     gitpod: {
-        service: import('../gitpod-service').GitpodService
-        ideService?: import('../ide-frontend-service').IDEFrontendService
-    }
-}
+        service: import("../gitpod-service").GitpodService;
+        ideService?: import("../ide-frontend-service").IDEFrontendService;
+    };
+}

package/src/util/analytics.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 Analytics = require("analytics-node");
+import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
+import { log } from "./logging";
+
+export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
+    switch (process.env.GITPOD_ANALYTICS_WRITER) {
+        case "segment":
+            return new SegmentAnalyticsWriter(process.env.GITPOD_ANALYTICS_SEGMENT_KEY || "");
+        case "log":
+            return new LogAnalyticsWriter();
+        default:
+            return new NoAnalyticsWriter();
+    }
+}
+
+class SegmentAnalyticsWriter implements IAnalyticsWriter {
+    protected readonly analytics: Analytics;
+
+    constructor(writeKey: string) {
+        this.analytics = new Analytics(writeKey);
+    }
+
+    identify(msg: IdentifyMessage) {
+        try {
+            this.analytics.identify(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.identify failed", err);
+                    }
+                },
+            );
+        } catch (err) {
+            log.warn("analytics.identify failed", err);
+        }
+    }
+
+    track(msg: TrackMessage) {
+        try {
+            this.analytics.track(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.track failed", err);
+                    }
+                },
+            );
+        } catch (err) {
+            log.warn("analytics.track failed", err);
+        }
+    }
+
+    page(msg: PageMessage) {
+        try {
+            this.analytics.page(
+                {
+                    ...msg,
+                    integrations: {
+                        All: true,
+                        Mixpanel: !!msg.userId,
+                    },
+                },
+                (err: Error) => {
+                    if (err) {
+                        log.warn("analytics.page failed", err);
+                    }
+                },
+            );
+        } catch (err) {
+            log.warn("analytics.page failed", err);
+        }
+    }
+}
+
+class LogAnalyticsWriter implements IAnalyticsWriter {
+    identify(msg: IdentifyMessage): void {
+        log.debug("analytics identify", msg);
+    }
+    track(msg: TrackMessage): void {
+        log.debug("analytics track", msg);
+    }
+    page(msg: PageMessage): void {
+        log.debug("analytics page", msg);
+    }
+}
+
+class NoAnalyticsWriter implements IAnalyticsWriter {
+    identify(msg: IdentifyMessage): void {}
+    track(msg: TrackMessage): void {}
+    page(msg: PageMessage): void {}
+}

package/src/util/async-iterator.ts

@@ -5,8 +5,8 @@
  */
 
 // Use asyncIterators with es2015
-if (typeof (Symbol as any).asyncIterator === 'undefined') {
-    (Symbol as any).asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator');
+if (typeof (Symbol as any).asyncIterator === "undefined") {
+    (Symbol as any).asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
 }
 
 export async function find<T>(it: AsyncIterableIterator<T>, predicate: (value: T) => boolean): Promise<T | undefined> {
@@ -31,12 +31,11 @@ export interface AsyncCachingIterator<T> extends AsyncIterableIterator<T> {
     resetCursor(): void;
 }
 export class AsyncCachingIteratorImpl<T> implements AsyncIterableIterator<T>, AsyncCachingIterator<T> {
-
     protected cache: T[] = [];
     protected cursor = 0;
     protected cacheRead = false;
 
-    constructor(protected readonly iterable: AsyncIterableIterator<T>) { }
+    constructor(protected readonly iterable: AsyncIterableIterator<T>) {}
 
     public resetCursor() {
         this.cursor = 0;
@@ -47,7 +46,7 @@ export class AsyncCachingIteratorImpl<T> implements AsyncIterableIterator<T>, As
         if (!this.cacheRead && this.cursor < this.cache.length) {
             return {
                 done: false,
-                value: this.cache[this.cursor++]
+                value: this.cache[this.cursor++],
             };
         }
         this.cacheRead = true;

package/src/util/cancelable.ts

@@ -9,10 +9,10 @@ import { Disposable } from "./disposable";
 export class Cancelable<T> implements Disposable {
     protected canceled: boolean;
 
-    constructor(protected readonly activity: (cancel: boolean) => Promise<T> | undefined) { }
+    constructor(protected readonly activity: (cancel: boolean) => Promise<T> | undefined) {}
 
     public async run(): Promise<T | undefined> {
-        for(let r = await this.activity(this.canceled); ; r = await this.activity(this.canceled)) {
+        for (let r = await this.activity(this.canceled); ; r = await this.activity(this.canceled)) {
             if (this.canceled) {
                 return;
             } else if (r !== undefined) {
@@ -28,4 +28,4 @@ export class Cancelable<T> implements Disposable {
     dispose(): void {
         this.cancel();
     }
-}
+}

package/src/util/date-time.ts

@@ -5,26 +5,26 @@
  */
 
 export function formatDate(date?: string) {
-    return date ? new Date(date).toLocaleString() : '';
+    return date ? new Date(date).toLocaleString() : "";
 }
 
 export function formatHours(hours?: number) {
     if (hours === undefined) {
-        return '';
+        return "";
     }
     const h = Math.floor(Math.abs(hours));
-    const rm = (Math.abs(hours) - h) * 60.;
+    const rm = (Math.abs(hours) - h) * 60;
     const m = Math.floor(rm);
-    const rs = (rm - m) * 60.;
+    const rs = (rm - m) * 60;
     const s = Math.floor(rs);
-    const result = h + ':' + pad2(m) + ':' + pad2(s);
+    const result = h + ":" + pad2(m) + ":" + pad2(s);
     if (hours < 0) {
-        return `-${result}`
+        return `-${result}`;
     } else {
-        return `${result}`
+        return `${result}`;
     }
 }
 
 function pad2(n: number) {
-    return n  < 10 ? '0' + n : '' + n;
+    return n < 10 ? "0" + n : "" + n;
 }

package/src/util/deferred.ts

@@ -19,12 +19,12 @@ export class Deferred<T> {
     promise = new Promise<T>((resolve, reject) => {
         this.resolve = (o) => {
             this.isResolved = true;
-            resolve(o)
-            clearTimeout(this.timer)
+            resolve(o as any);
+            clearTimeout(this.timer);
         };
         this.reject = (e) => {
-            reject(e)
-            clearTimeout(this.timer)
-        }
+            reject(e);
+            clearTimeout(this.timer);
+        };
     });
-}
+}

package/src/util/disposable.ts

@@ -16,10 +16,10 @@ export interface Disposable {
 export namespace Disposable {
     export function create(func: () => void): Disposable {
         return {
-            dispose: func
+            dispose: func,
         };
     }
-    export const NULL = create(() => { });
+    export const NULL = create(() => {});
 }
 
 export class DisposableCollection implements Disposable {
@@ -69,9 +69,6 @@ export class DisposableCollection implements Disposable {
     }
 
     pushAll(disposables: Disposable[]): Disposable[] {
-        return disposables.map(disposable =>
-            this.push(disposable)
-        );
+        return disposables.map((disposable) => this.push(disposable));
     }
-
 }

package/src/util/event.ts

@@ -6,13 +6,12 @@
  */
 
 import { Disposable } from "./disposable";
-import { log } from './logging';
+import { log } from "./logging";
 
 /**
  * Represents a typed event.
  */
 export interface Event<T> {
-
     /**
      *
      * @param listener The listener function will be call when the event happens.
@@ -24,12 +23,13 @@ export interface Event<T> {
 }
 
 export namespace Event {
-    const _disposable = { dispose() { } };
-    export const None: Event<any> = function () { return _disposable; };
+    const _disposable = { dispose() {} };
+    export const None: Event<any> = function () {
+        return _disposable;
+    };
 }
 
 class CallbackList {
-
     private _callbacks: Function[] | undefined;
     private _contexts: any[] | undefined;
 
@@ -66,7 +66,7 @@ class CallbackList {
         }
 
         if (foundCallbackWithDifferentContext) {
-            throw new Error('When adding a listener with a context, you should remove it with the same context');
+            throw new Error("When adding a listener with a context, you should remove it with the same context");
         }
     }
 
@@ -105,14 +105,12 @@ export interface EmitterOptions {
 }
 
 export class Emitter<T> {
-
-    private static _noop = function () { };
+    private static _noop = function () {};
 
     private _event: Event<T>;
     private _callbacks: CallbackList | undefined;
 
-    constructor(private _options?: EmitterOptions) {
-    }
+    constructor(private _options?: EmitterOptions) {}
 
     /**
      * For the public to allow to subscribe
@@ -137,7 +135,7 @@ export class Emitter<T> {
                         if (this._options && this._options.onLastListenerRemove && this._callbacks!.isEmpty()) {
                             this._options.onLastListenerRemove(this);
                         }
-                    }
+                    },
                 };
                 if (Array.isArray(disposables)) {
                     disposables.push(result);