@gitpod/gitpod-protocol 0.1.5-private-repos-after-cancellation.0 → 0.1.5-protected-secrets.0

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

@@ -4,8 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { Without } from "./util/without";
-import uuidv4 = require("uuid/v4");
+import { v4 as uuidv4 } from "uuid";
 import { Subscription } from "./accounting-protocol";
 
 export interface TeamSubscription {
@@ -19,16 +18,45 @@ export interface TeamSubscription {
     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: Without<TeamSubscription, 'id'>): 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);
+    };
+    export function isCancelled(s: TeamSubscription2, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
     }
 }
 
@@ -43,49 +71,57 @@ export interface TeamSubscriptionSlot {
     subscriptionId?: string;
     cancellationDate?: string;
 }
-export type TeamSubscriptionSlotDeactivated = TeamSubscriptionSlot & { assigneeId: string, assigneeIdentifier: AssigneeIdentifier };
-export type TeamSubscriptionSlotAssigned = TeamSubscriptionSlot & TeamSubscriptionSlotDeactivated & { subscriptionId: string };
+export type TeamSubscriptionSlotDeactivated = TeamSubscriptionSlot & {
+    assigneeId: string;
+    assigneeIdentifier: AssigneeIdentifier;
+};
+export type TeamSubscriptionSlotAssigned = TeamSubscriptionSlot &
+    TeamSubscriptionSlotDeactivated & { subscriptionId: string };
 
-export type TeamSubscriptionSlotState = 'unassigned' | 'assigned' | 'deactivated' | 'cancelled';
+export type TeamSubscriptionSlotState = "unassigned" | "assigned" | "deactivated" | "cancelled";
 
 export namespace TeamSubscriptionSlot {
-    export const create = (ts: Without<TeamSubscriptionSlot, 'id'>): 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) => {
+    };
+    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';
+                return "cancelled";
             } else {
-                return 'deactivated';
+                return "deactivated";
             }
         } else {
             if (slot.subscriptionId) {
-                return 'assigned';
+                return "assigned";
             } else {
-                return 'unassigned';
+                return "unassigned";
             }
         }
-
-    }
+    };
     export const isActive = (slot: TeamSubscriptionSlot): boolean => {
         return !slot.cancellationDate;
-    }
+    };
 }
 
 /**
@@ -108,7 +144,7 @@ export interface TeamSubscriptionSlotResolved {
 export type AssigneeIdentifier = AssigneeIdentityIdentifier;
 export interface AssigneeIdentityIdentifier {
     identity: {
-        authHost: string,
-        authName: string
-    }
+        authHost: string;
+        authName: string;
+    };
 }

package/src/teams-projects-protocol.ts

@@ -0,0 +1,166 @@
+/**
+ * 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";
+import { WebhookEvent } from "./webhook-event";
+
+export interface ProjectConfig {
+    ".gitpod.yml": string;
+}
+
+export interface ProjectSettings {
+    useIncrementalPrebuilds?: boolean;
+    usePersistentVolumeClaim?: boolean;
+    keepOutdatedPrebuildsRunning?: boolean;
+}
+
+export interface Project {
+    id: string;
+    name: string;
+    slug?: string;
+    cloneUrl: string;
+    teamId?: string;
+    userId?: string;
+    appInstallationId: string;
+    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;
+}
+
+export interface PrebuildEvent {
+    id: string;
+    creationTime: string;
+    status: WebhookEvent.Status | WebhookEvent.PrebuildStatus;
+    message?: string;
+    prebuildId?: string;
+    projectId?: string;
+    cloneUrl?: string;
+    branch?: string;
+    commit?: string;
+}

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/usage.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { WorkspaceType } from "./protocol";
+
+// types below are copied over from components/usage-api/typescript/src/usage/v1/usage_pb.d.ts
+export interface ListUsageRequest {
+    attributionId: string;
+    from?: number;
+    to?: number;
+    order: Ordering;
+    pagination?: PaginationRequest;
+}
+
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
+
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
+
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditsUsed: number;
+}
+
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
+}
+
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
+    attributionId: string;
+    description: string;
+    credits: number;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
+}
+
+// the equivalent golang shape is maintained in `/workspace/gitpod/`components/usage/pkg/db/usage.go`
+export interface WorkspaceInstanceUsageData {
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+    workspaceClass: string;
+    contextURL: string;
+    startTime: string;
+    endTime?: string;
+    userId: string;
+    userName: string;
+    userAvatarURL: string;
+}
+
+export interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
+}

package/src/util/analytics.ts

@@ -5,9 +5,8 @@
  */
 
 import Analytics = require("analytics-node");
-import { IAnalyticsWriter, IdentifyMessage, TrackMessage } from "../analytics";
-import { log } from './logging';
-
+import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
+import { log } from "./logging";
 
 export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
     switch (process.env.GITPOD_ANALYTICS_WRITER) {
@@ -21,20 +20,28 @@ export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
 }
 
 class SegmentAnalyticsWriter implements IAnalyticsWriter {
-
     protected readonly analytics: Analytics;
 
     constructor(writeKey: string) {
         this.analytics = new Analytics(writeKey);
     }
 
-        identify(msg: IdentifyMessage) {
+    identify(msg: IdentifyMessage) {
         try {
-            this.analytics.identify(msg, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.identify failed", err);
-                }
-            });
+            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);
         }
@@ -42,30 +49,61 @@ class SegmentAnalyticsWriter implements IAnalyticsWriter {
 
     track(msg: TrackMessage) {
         try {
-            this.analytics.track(msg, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.track failed", err);
-                }
-            });
+            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;
 }