@gitpod/gitpod-protocol 0.1.5-vn-integrate-gitpod-yml-tasks-into-jetbrainsa.5 → 0.1.5-vn-6525.77

package/src/snapshot-url.spec.ts

@@ -4,16 +4,18 @@
  * 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 { SnapshotUrl } from ".";
 
-const expect = chai.expect
-
-@suite class TestSnapshotUrlParser {
+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");
+        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",
@@ -22,4 +24,4 @@ const expect = chai.expect
         });
     }
 }
-module.exports = new TestSnapshotUrlParser()   // Only to circumvent no usage warning :-/
+module.exports = new TestSnapshotUrlParser(); // Only to circumvent no usage warning :-/

package/src/team-subscription-protocol.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 import { Subscription } from "./accounting-protocol";
 
 export interface TeamSubscription {
@@ -18,17 +18,19 @@ 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: Omit<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);
-    }
+    };
 }
 
 /**
@@ -42,49 +44,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: Omit<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;
-    }
+    };
 }
 
 /**
@@ -107,7 +117,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

@@ -5,11 +5,11 @@
  */
 
 import { PrebuiltWorkspaceState } from "./protocol";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 import { DeepPartial } from "./util/deep-partial";
 
 export interface ProjectConfig {
-    '.gitpod.yml': string;
+    ".gitpod.yml": string;
 }
 
 export interface ProjectSettings {
@@ -33,13 +33,13 @@ export interface Project {
 }
 
 export namespace Project {
-    export const create = (project: Omit<Project, 'id' | 'creationTime'>): Project => {
+    export const create = (project: Omit<Project, "id" | "creationTime">): Project => {
         return {
             ...project,
             id: uuidv4(),
-            creationTime: new Date().toISOString()
+            creationTime: new Date().toISOString(),
         };
-    }
+    };
 
     export interface Overview {
         branches: BranchDetails[];
@@ -67,7 +67,7 @@ export namespace Project {
     }
 }
 
-export type PartialProject = DeepPartial<Project> & Pick<Project, 'id'>;
+export type PartialProject = DeepPartial<Project> & Pick<Project, "id">;
 
 export interface PrebuildWithStatus {
     info: PrebuildInfo;
@@ -103,7 +103,7 @@ export interface PrebuildInfo {
 }
 export namespace PrebuildInfo {
     export function is(data?: any): data is PrebuildInfo {
-        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every(p => p in data);
+        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every((p) => p in data);
     }
 }
 
@@ -144,4 +144,4 @@ export interface TeamMembershipInvite {
 
     /** 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

@@ -6,8 +6,7 @@
 
 import Analytics = require("analytics-node");
 import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
-import { log } from './logging';
-
+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,32 +49,48 @@ 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, (err: Error) => {
-                if (err) {
-                    log.warn("analytics.page failed", err);
-                }
-            });
+        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);
     }
@@ -77,11 +100,10 @@ class LogAnalyticsWriter implements IAnalyticsWriter {
     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 as any)
-            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);

package/src/util/garbage-collected-cache.ts

@@ -6,7 +6,6 @@
 
 import { repeat } from "./repeat";
 
-
 interface CacheEntry<T> {
     key: string;
     value: T;
@@ -16,9 +15,7 @@ interface CacheEntry<T> {
 export class GarbageCollectedCache<T> {
     protected readonly store = new Map<string, CacheEntry<T>>();
 
-    constructor(
-        protected readonly defaultMaxAgeSeconds: number,
-        protected readonly gcIntervalSeconds: number) {
+    constructor(protected readonly defaultMaxAgeSeconds: number, protected readonly gcIntervalSeconds: number) {
         this.regularlyCollectGarbage();
     }
 
@@ -61,6 +58,6 @@ export class GarbageCollectedCache<T> {
     }
 
     protected calcExpiryDate(maxAgeSeconds?: number): number {
-        return Date.now() + ((maxAgeSeconds || this.defaultMaxAgeSeconds) * 1000);
+        return Date.now() + (maxAgeSeconds || this.defaultMaxAgeSeconds) * 1000;
     }
-}
+}

package/src/util/generate-workspace-id.spec.ts

@@ -4,15 +4,15 @@
  * 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 { generateWorkspaceID, colors, animals } from "./generate-workspace-id";
 import { GitpodHostUrl } from "./gitpod-host-url";
 
-const expect = chai.expect
-
-@suite class TestGenerateWorkspaceId {
+const expect = chai.expect;
 
+@suite
+class TestGenerateWorkspaceId {
     @test public async testGenerateWorkspaceId() {
         for (let i = 0; i < 100; i++) {
             const id = await generateWorkspaceID();
@@ -29,20 +29,23 @@ const expect = chai.expect
 
     @test public async testCustomName() {
         const data = [
-            ['foo','bar','foo-bar-'],
-            ['f','bar','.{2,16}-bar-'],
-            ['gitpod-io','gitpod','gitpodio-gitpod-'],
-            ['this is rather long and has some "§$"% special chars','also here pretty long and needs abbreviation','thisisratherlon-alsohere-'],
-            ['breatheco-de', 'python-flask-api-tutorial', 'breathecode-pythonflaska-'],
-            ['UPPER', "CaSe", "upper-case-"]
-        ]
+            ["foo", "bar", "foo-bar-"],
+            ["f", "bar", ".{2,16}-bar-"],
+            ["gitpod-io", "gitpod", "gitpodio-gitpod-"],
+            [
+                'this is rather long and has some "§$"% special chars',
+                "also here pretty long and needs abbreviation",
+                "thisisratherlon-alsohere-",
+            ],
+            ["breatheco-de", "python-flask-api-tutorial", "breathecode-pythonflaska-"],
+            ["UPPER", "CaSe", "upper-case-"],
+        ];
         for (const d of data) {
             const id = await generateWorkspaceID(d[0], d[1]);
-            expect(id).match(new RegExp("^"+d[2]));
+            expect(id).match(new RegExp("^" + d[2]));
             expect(new GitpodHostUrl().withWorkspacePrefix(id, "eu").workspaceId).to.equal(id);
             expect(id.length <= 36, `"${id}" is longer than 36 chars (${id.length})`).to.be.true;
         }
     }
-
 }
-module.exports = new TestGenerateWorkspaceId()
+module.exports = new TestGenerateWorkspaceId();