@gitpod/gitpod-protocol 0.1.5-update-ovsx.0 → 0.1.5-update-yarnlock.0

package/src/util/parse-workspace-id.ts

@@ -1,24 +1,54 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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.
  */
 
+const REGEX_WORKSPACE_ID = /[0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8,11}/;
+const REGEX_WORKSPACE_ID_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID.source}$`);
+// We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
+const REGEX_WORKSPACE_ID_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID.source})\.ws`);
+
+const REGEX_WORKSPACE_ID_LEGACY = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_WORKSPACE_ID_LEGACY_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID_LEGACY.source}$`);
+const REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID_LEGACY.source})\.ws`);
 
 /**
  * Hostname may be of the form:
- *  - b7e0eaf8-ec73-44ec-81ea-04859263b656.ws-eu01.gitpod.io
- *  - 1234-b7e0eaf8-ec73-44ec-81ea-04859263b656.ws-eu01.gitpod.io
- *  - webview-1234-b7e0eaf8-ec73-44ec-81ea-04859263b656.ws-eu01.gitpod.io (or any other string replacing webview)
+ *  - moccasin-ferret-155799b3.ws-eu01.gitpod.io
+ *  - 1234-moccasin-ferret-155799b3.ws-eu01.gitpod.io
+ *  - webview-1234-moccasin-ferret-155799b3.ws-eu01.gitpod.io (or any other string replacing webview)
  * @param hostname The hostname the request is headed to
  */
-export const parseWorkspaceIdFromHostname = function(hostname: string) {
-    // We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
-    const wsIdExpression = /([a-z][0-9a-z]+\-([0-9a-z]+\-){3}[0-9a-z]+)\.ws/g;
-    const match = wsIdExpression.exec(hostname);
+export const parseWorkspaceIdFromHostname = function (hostname: string) {
+    const match = REGEX_WORKSPACE_ID_FROM_HOSTNAME.exec(hostname);
     if (match && match.length >= 2) {
         return match[1];
     } else {
+        const legacyMatch = REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME.exec(hostname);
+        if (legacyMatch && legacyMatch.length >= 2) {
+            return legacyMatch[1];
+        }
         return undefined;
     }
-}
+};
+
+/** Equalls UUIDv4 (and REGEX_WORKSPACE_ID_LEGACY!) */
+const REGEX_INSTANCE_ID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_INSTANCE_ID_EXACT = new RegExp(`^${REGEX_INSTANCE_ID.source}$`);
+
+/**
+ * @param maybeId
+ * @returns
+ */
+export const matchesInstanceIdOrLegacyWorkspaceIdExactly = function (maybeId: string): boolean {
+    return REGEX_INSTANCE_ID_EXACT.test(maybeId) || REGEX_WORKSPACE_ID_LEGACY_EXACT.test(maybeId);
+};
+
+/**
+ * @param maybeWorkspaceId
+ * @returns
+ */
+export const matchesNewWorkspaceIdExactly = function (maybeWorkspaceId: string): boolean {
+    return REGEX_WORKSPACE_ID_EXACT.test(maybeWorkspaceId);
+};

package/src/util/queue.spec.ts

@@ -1,22 +1,22 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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, slow, timeout } from 'mocha-typescript'
-import * as chai from 'chai'
-const chaiSubset = require('chai-subset');
+import { suite, test, slow, timeout } from "mocha-typescript";
+import * as chai from "chai";
+const chaiSubset = require("chai-subset");
 chai.use(chaiSubset);
 
-import { Queue } from '..';
-import { fail } from 'assert';
-import { Deferred } from './deferred';
+import { Queue } from "..";
+import { fail } from "assert";
+import { Deferred } from "./deferred";
 
-const expect = chai.expect
-
-@suite class QueueSpec {
+const expect = chai.expect;
 
+@suite
+class QueueSpec {
     queue: Queue;
     seq: number[];
 
@@ -32,11 +32,10 @@ const expect = chai.expect
                     return new Promise((resolve) => {
                         setTimeout(() => {
                             this.seq.push(seqNr);
-                            resolve();
+                            resolve(undefined);
                         }, sleep);
                     });
-                else
-                    this.seq.push(seqNr);
+                else this.seq.push(seqNr);
             };
 
             if (nextTick)
@@ -45,20 +44,22 @@ const expect = chai.expect
                         push().then(resolve);
                     });
                 });
-            else
-                await push();
+            else await push();
         });
     }
     execError(seqNr: number): Deferred<boolean> {
         const deferred = new Deferred<boolean>();
-        this.queue.enqueue(async () => {
-            this.seq.push(seqNr);
-            throw new Error('test error');
-        }).then(() => {
-            deferred.reject(false);
-        }).catch(() => {
-            deferred.resolve(true);
-        });
+        this.queue
+            .enqueue(async () => {
+                this.seq.push(seqNr);
+                throw new Error("test error");
+            })
+            .then(() => {
+                deferred.reject(false);
+            })
+            .catch(() => {
+                deferred.resolve(true);
+            });
 
         return deferred;
     }
@@ -67,7 +68,9 @@ const expect = chai.expect
         expect(actual).to.have.lengthOf(expected.length);
         const expIt = expected.entries();
         for (const act of actual) {
-            const { value: [, exp] } = expIt.next();
+            const {
+                value: [, exp],
+            } = expIt.next();
             expect(act).to.deep.equal(exp);
         }
     }
@@ -93,7 +96,6 @@ const expect = chai.expect
         this.expectArray(this.seq, [1, 2]);
     }
 
-
     @test public async continueDespiteError() {
         this.exec(1);
         const receivedError = this.execError(2);
@@ -107,7 +109,7 @@ const expect = chai.expect
     @test public async mustCatchError() {
         const f = async () => {
             throw new Error();
-        }
+        };
         try {
             const p = this.queue.enqueue(async () => {
                 return f();
@@ -124,7 +126,7 @@ const expect = chai.expect
     @test public async expectUncaughtError() {
         const f = async () => {
             throw new Error();
-        }
+        };
         const p = this.queue.enqueue(async () => {
             return f();
         });

package/src/util/queue.ts

@@ -1,7 +1,7 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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 { Deferred } from "./deferred";

package/src/util/repeat.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { Disposable } from "..";
+import { log } from "./logging";
+
+/**
+ * This intends to be a drop-in replacement for 'setInterval' implemented with a 'setTimeout' chain
+ * to ensure we're not creating more timeouts than we can process.
+ * @param op
+ * @param everyMilliseconds
+ * @returns
+ */
+export function repeat(op: () => Promise<void> | void, everyMilliseconds: number): Disposable {
+    let timer: NodeJS.Timeout | undefined = undefined;
+    let stopped = false;
+    const repeated = () => {
+        if (stopped) {
+            // in case we missed the clearTimeout i 'await'
+            return;
+        }
+
+        timer = setTimeout(async () => {
+            try {
+                await op();
+            } catch (err) {
+                // catch error here to
+                log.error(err);
+            }
+
+            repeated(); // chain ourselves - after the 'await'
+        }, everyMilliseconds);
+    };
+    repeated();
+
+    return Disposable.create(() => {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
+}

package/src/util/semaphore.ts

@@ -1,23 +1,22 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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.
  */
 
-
 export class Semaphore {
     protected queue: (() => void)[] = [];
     protected used: number;
 
-    constructor(protected readonly capacity: number) { 
-        if(capacity < 1) {
+    constructor(protected readonly capacity: number) {
+        if (capacity < 1) {
             throw new Error("Capacity cannot be less than 1");
         }
     }
 
     public release() {
-        if(this.used == 0) return;
-        
+        if (this.used == 0) return;
+
         const queued = this.queue.shift();
         if (queued) {
             queued();
@@ -28,7 +27,7 @@ export class Semaphore {
 
     public async acquire(): Promise<void> {
         this.used++;
-        if(this.used <= this.capacity) {
+        if (this.used <= this.capacity) {
             return Promise.resolve();
         }
 
@@ -36,5 +35,4 @@ export class Semaphore {
             this.queue.push(rs);
         });
     }
-
-}
+}

package/src/util/skip-if.ts

@@ -1,10 +1,9 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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.
  */
 
-
 /**
  * The subset of actually available fields and methods which are not exported but we care about
  */
@@ -18,16 +17,20 @@ interface TestSuiteContext extends Mocha.ISuiteCallbackContext {
  * @param doSkip A function which takes a TestSuite and decides if it should be skipped
  */
 export function skipIf(doSkip: (suite: TestSuiteContext) => boolean): MochaTypeScript.SuiteTrait {
-    const trait: MochaTypeScript.SuiteTrait = function(this: Mocha.ISuiteCallbackContext, ctx: Mocha.ISuiteCallbackContext, ctor: Function): void {
-        const suite = ctx as any as TestSuiteContext;  // No idea why those fields are not exported in the types
+    const trait: MochaTypeScript.SuiteTrait = function (
+        this: Mocha.ISuiteCallbackContext,
+        ctx: Mocha.ISuiteCallbackContext,
+        ctor: Function,
+    ): void {
+        const suite = ctx as any as TestSuiteContext; // No idea why those fields are not exported in the types
         const skip = doSkip(suite);
-        suite.beforeEach(function(this: Mocha.IHookCallbackContext) {
+        suite.beforeEach(function (this: Mocha.IHookCallbackContext) {
             if (skip) {
                 this.skip();
             }
-        })
+        });
     };
-    
+
     // Mark as "trait": mimics the behavior of https://github.com/testdeck/testdeck/blob/9d2dd6a458c2c86c945f6f2999b8278b7528a7a7/index.ts#L433
     (trait as any)["__mts_isTrait"] = true;
     return trait;
@@ -45,4 +48,4 @@ export function skipIfEnvVarNotSet(name: string): MochaTypeScript.SuiteTrait {
         }
         return skip;
     });
-}
+}

package/src/util/timeutil.spec.ts

@@ -1,43 +1,69 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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 * as chai from 'chai';
+import * as chai from "chai";
 const expect = chai.expect;
-import { suite, test } from 'mocha-typescript';
-import { oneMonthLater } from './timeutil';
+import { suite, test } from "mocha-typescript";
+import { daysBefore, hoursBefore, oneMonthLater } from "./timeutil";
 
 @suite()
 export class TimeutilSpec {
+    @test
+    testDaysBefore() {
+        const now = new Date().toISOString();
+        expect(daysBefore(now, 2)).to.be.eq(hoursBefore(now, 48));
+    }
 
     @test
     testTimeutil() {
         // targeting a 1st, 1th of Jan => 1st of Feb
-        this.isOneMonthLater(new Date(2000, 0, 1), 1, new Date(2000, 1, 1))
+        this.isOneMonthLater(new Date(2000, 0, 1), 1, new Date(2000, 1, 1));
 
         // targeting a 31th, 30th of Apr => 31st of May
-        this.isOneMonthLater(new Date(2000, 3, 30), 31, new Date(2000, 4, 31))
+        this.isOneMonthLater(new Date(2000, 3, 30), 31, new Date(2000, 4, 31));
 
         // targeting a 31th, 31th of Mar => 30th of Apr
-        this.isOneMonthLater(new Date(2000, 2, 31), 31, new Date(2000, 3, 30))
+        this.isOneMonthLater(new Date(2000, 2, 31), 31, new Date(2000, 3, 30));
 
         // targeting a 30th, 30th of Mar => 30th of Apr
-        this.isOneMonthLater(new Date(2000, 2, 30), 30, new Date(2000, 3, 30))
+        this.isOneMonthLater(new Date(2000, 2, 30), 30, new Date(2000, 3, 30));
 
         // next year
-        this.isOneMonthLater(new Date(2000, 11, 1), 1, new Date(2001, 0, 1))
-        this.isOneMonthLater(new Date(2000, 11, 31), 31, new Date(2001, 0, 31))
+        this.isOneMonthLater(new Date(2000, 11, 1), 1, new Date(2001, 0, 1));
+        this.isOneMonthLater(new Date(2000, 11, 31), 31, new Date(2001, 0, 31));
 
         // Feb
-        this.isOneMonthLater(new Date(2001, 0, 31), 31, new Date(2001, 1, 28))
+        this.isOneMonthLater(new Date(2001, 0, 31), 31, new Date(2001, 1, 28));
         // Feb leap year
-        this.isOneMonthLater(new Date(2000, 0, 31), 31, new Date(2000, 1, 29))
+        this.isOneMonthLater(new Date(2000, 0, 31), 31, new Date(2000, 1, 29));
     }
 
     isOneMonthLater(from: Date, day: number, expectation: Date) {
-        const later = oneMonthLater(from.toISOString(), day)
-        expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString())
+        const later = oneMonthLater(from.toISOString(), day);
+        expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString());
+    }
+
+    @test
+    testDaysBefore2() {
+        const tests: { date: Date; daysEarlier: number; expectation: string }[] = [
+            {
+                date: new Date("2021-07-13T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2020-07-13T00:00:00.000Z",
+            },
+            {
+                date: new Date("2019-02-01T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2018-02-01T00:00:00.000Z",
+            },
+        ];
+
+        for (const t of tests) {
+            const actual = daysBefore(t.date.toISOString(), t.daysEarlier);
+            expect(actual).to.equal(t.expectation, `expected ${actual} to be equal ${t.expectation}`);
+        }
     }
-}
+}

package/src/util/timeutil.ts

@@ -1,17 +1,17 @@
 /**
- * Copyright (c) 2020 TypeFox GmbH. All rights reserved.
+ * 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.
  */
 
 /**
  * Returns the <code>day</code>th of the next month from <code>formDate</code>.
- * If the next month does not have a <code>day</code>th, the last day of that 
+ * If the next month does not have a <code>day</code>th, the last day of that
  * month is taken.
  * The time is copied from <code>fromDate</code>.
- * 
- * @param fromDate 
- * @param day 
+ *
+ * @param fromDate
+ * @param day
  */
 export function oneMonthLater(fromDate: string, day?: number): string {
     const later = new Date(fromDate);
@@ -24,28 +24,44 @@ export function oneMonthLater(fromDate: string, day?: number): string {
     }
     return later.toISOString();
 }
-export const yearsLater = (fromDate: string, years: number): string => liftDate1(fromDate, (d) => {
-    d.setUTCFullYear(d.getUTCFullYear() + years);
-    return d.toISOString();
-});
+export const yearsLater = (fromDate: string, years: number): string =>
+    liftDate1(fromDate, (d) => {
+        d.setUTCFullYear(d.getUTCFullYear() + years);
+        return d.toISOString();
+    });
 
 // tslint:disable-next-line:no-shadowed-variable
-export const addMillis = (d1: string, millis: number) => liftDate1(d1, (d1) => new Date(d1.getTime() + millis).toISOString());
-export const durationInHours = (d1: string, d2: string) => liftDate(d1, d2, (d1, d2) => millisecondsToHours(d1.getTime() - d2.getTime()));
+export const addMillis = (d1: string, millis: number) =>
+    liftDate1(d1, (d1) => new Date(d1.getTime() + millis).toISOString());
+export const durationInHours = (d1: string, d2: string) =>
+    liftDate(d1, d2, (d1, d2) => millisecondsToHours(d1.getTime() - d2.getTime()));
 export const durationInMillis = (d1: string, d2: string) => liftDate(d1, d2, (d1, d2) => d1.getTime() - d2.getTime());
 // tslint:disable-next-line:no-shadowed-variable
-export const isDateGreaterOrEqual = (d1: string, d2: string): boolean => liftDate(d1, d2, (d1, d2) => d1.getTime() >= d2.getTime());
+export const isDateGreaterOrEqual = (d1: string, d2: string): boolean =>
+    liftDate(d1, d2, (d1, d2) => d1.getTime() >= d2.getTime());
 export const isDateSmallerOrEqual = (d1: string, d2: string | undefined) => !d2 || d1 <= d2;
 export const isDateSmaller = (d1: string, d2: string | undefined) => !d2 || d1 < d2;
-export const oldest = (d1: string, d2: string): string => d1 > d2 ? d1 : d2;
-export const earliest = (d1: string, d2: string): string => d1 < d2 ? d1 : d2;
+export const oldest = (d1: string, d2: string): string => (d1 > d2 ? d1 : d2);
+export const earliest = (d1: string, d2: string): string => (d1 < d2 ? d1 : d2);
 export const orderAsc = (d1: string, d2: string): number => liftDate(d1, d2, (d1, d2) => d1.getTime() - d2.getTime());
 export const liftDate1 = <T>(d1: string, f: (d1: Date) => T): T => f(new Date(d1));
 export const liftDate = <T>(d1: string, d2: string, f: (d1: Date, d2: Date) => T): T => f(new Date(d1), new Date(d2));
 
+export function daysBefore(date: string, days: number): string {
+    const result = new Date(date);
+    result.setDate(result.getDate() - days);
+    return result.toISOString();
+}
+
+export function hoursBefore(date: string, hours: number): string {
+    const result = new Date(date);
+    result.setHours(result.getHours() - hours);
+    return result.toISOString();
+}
+
 export function hoursLater(date: string, hours: number): string {
-    const result = new Date(date)
-    result.setHours(result.getHours() + hours)
+    const result = new Date(date);
+    result.setHours(result.getHours() + hours);
     return result.toISOString();
 }
 

package/src/util/tracing.spec.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { suite, test } from "mocha-typescript";
+import * as chai from "chai";
+import { TraceContext } from "./tracing";
+import { MockTracer } from "opentracing";
+
+const expect = chai.expect;
+
+@suite
+class TestTracing {
+    @test public async testTracingContext_addNestedTags() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan("testTracingContext_addNestedTags");
+        TraceContext.addNestedTags(
+            { span },
+            {
+                rpc: {
+                    system: "jsonrpc",
+                    jsonrpc: {
+                        version: "1.0",
+                        method: "test",
+                        parameters: ["abc", "def"],
+                    },
+                },
+            },
+        );
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "rpc.system": "jsonrpc",
+            "rpc.jsonrpc.version": "1.0",
+            "rpc.jsonrpc.method": "test",
+            "rpc.jsonrpc.parameters.0": "abc",
+            "rpc.jsonrpc.parameters.1": "def",
+        });
+    }
+
+    @test public async testTracingContext_addNestedTags_null() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan("testTracingContext_addNestedTags_null");
+        TraceContext.addNestedTags(
+            { span },
+            {
+                someShape: {
+                    thisIsNull: null,
+                    thisIsUndefined: undefined,
+                },
+            },
+        );
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "someShape.thisIsNull": null,
+            "someShape.thisIsUndefined": undefined,
+        });
+    }
+
+    @test public async testTracingContext_addJsonRPCParameters() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan("testTracingContext_addJsonRPCParameters");
+        const ctx = { span };
+        TraceContext.addJsonRPCParameters(ctx, {
+            one: "one",
+            two: {
+                name: "two",
+                some: "shape",
+                containing: "PII",
+            },
+            three: "three",
+        });
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "rpc.jsonrpc.parameters.one": "one",
+            "rpc.jsonrpc.parameters.two.containing": "PII",
+            "rpc.jsonrpc.parameters.two.name": "two",
+            "rpc.jsonrpc.parameters.two.some": "shape",
+            "rpc.jsonrpc.parameters.three": "three",
+            "rpc.system": "jsonrpc",
+        });
+    }
+}
+module.exports = new TestTracing();