@gitpod/gitpod-protocol 0.1.5-se-workspace-for-teams.18 → 0.1.5-se-workspaceid.9

package/src/util/gitpod-host-url.ts

@@ -12,13 +12,13 @@ export interface UrlChange {
 }
 export type UrlUpdate = UrlChange | Partial<URL>;
 
-const basewoWkspaceIDRegex = "(([a-f][0-9a-f]{7}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8}))";
+const baseWorkspaceIDRegex = "(([a-f][0-9a-f]{7}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8,11}))";
 
 // this pattern matches v4 UUIDs as well as the new generated workspace ids (e.g. pink-panda-ns35kd21)
-const workspaceIDRegex = RegExp(`^${basewoWkspaceIDRegex}$`);
+const workspaceIDRegex = RegExp(`^${baseWorkspaceIDRegex}$`);
 
 // this pattern matches URL prefixes of workspaces
-const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${basewoWkspaceIDRegex}\\.`);
+const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${baseWorkspaceIDRegex}\\.`);
 
 export class GitpodHostUrl {
     readonly url: URL;
@@ -85,23 +85,27 @@ export class GitpodHostUrl {
     }
 
     asDashboard(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/workspaces/' }));
+        return this.with(url => ({ pathname: '/' }));
     }
 
     asLogin(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/login/' }));
+        return this.with(url => ({ pathname: '/login' }));
     }
 
     asUpgradeSubscription(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/plans/' }));
+        return this.with(url => ({ pathname: '/plans' }));
     }
 
     asAccessControl(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/access-control/' }));
+        return this.with(url => ({ pathname: '/integrations' }));
     }
 
     asSettings(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/settings/' }));
+        return this.with(url => ({ pathname: '/settings' }));
+    }
+
+    asPreferences(): GitpodHostUrl {
+        return this.with(url => ({ pathname: '/preferences' }));
     }
 
     asGraphQLApi(): GitpodHostUrl {

package/src/util/grpc.ts

@@ -5,9 +5,9 @@
  */
 
  export const defaultGRPCOptions = {
-    "grpc.keepalive_timeout_ms": 1000,
-    "grpc.keepalive_time_ms": 5000,
-    "grpc.http2.min_time_between_pings_ms": 1000,
+    "grpc.keepalive_timeout_ms": 10000,
+    "grpc.keepalive_time_ms": 60000,
+    "grpc.http2.min_time_between_pings_ms": 10000,
     "grpc.keepalive_permit_without_calls": 1,
     "grpc-node.max_session_memory": 50,
     "grpc.max_reconnect_backoff_ms": 5000,

package/src/util/jaeger-client-types.ts

@@ -0,0 +1,102 @@
+/**
+ * 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 { opentracing } from "jaeger-client";
+
+// Type definitions for jaeger-client which are not exported by @types/jaeger-client
+// Project: https://github.com/uber/jaeger-client-node
+// Definitions by: Julian Steger <https://github.com/julianste>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export interface TracingConfig {
+    serviceName?: string;
+    disable?: boolean;
+    sampler?: SamplerConfig;
+    reporter?: ReporterConfig;
+}
+
+export interface TracingOptions {
+    reporter?: Reporter;
+    metrics?: MetricsFactory;
+    logger?: Logger;
+    tags?: any;
+}
+
+export interface ReporterConfig {
+    logSpans?: boolean;
+    agentHost?: string;
+    agentPort?: number;
+    flushIntervalMs?: number;
+}
+
+export interface SamplerConfig {
+    type: string;
+    param: number;
+    host?: string;
+    port?: number;
+    refreshIntervalMs?: number;
+}
+
+export interface Logger {
+    info(msg: string): void;
+    error(msg: string): void;
+}
+
+export interface Reporter {
+    report(span: opentracing.Span): void;
+    close(callback?: () => void): void;
+    setProcess(serviceName: string, tags: any): void;
+}
+
+export interface MetricsFactory {
+    createCounter(name: string, tags: any): Counter;
+    createTimer(name: string, tags: any): Timer;
+    createGauge(name: string, tags: any): Gauge;
+}
+
+// Counter tracks the number of times an event has occurred
+export interface Counter {
+    // Adds the given value to the counter.
+    increment(delta: number): void;
+}
+
+// Timer tracks how long an operation took and also computes percentiles.
+export interface Timer {
+    // Records the time passed in.
+    record(value: number): void;
+}
+
+// Gauge returns instantaneous measurements of something as an int64 value
+export interface Gauge {
+    // Update the gauge to the value passed in.
+    update(value: number): void;
+}
+
+// export function initTracer(
+//     tracingConfig: TracingConfig,
+//     tracingOptions: TracingOptions,
+// ): opentracing.Tracer;
+
+// export function initTracerFromEnv(
+//     tracingConfig: TracingConfig,
+//     tracingOptions: TracingOptions,
+// ): opentracing.Tracer;
+
+export interface SamplingDecision {
+    sample: boolean;
+    retryable: boolean;
+    tags: any;
+}
+
+// added by TypeFox
+export interface Sampler {
+    name(): string
+    isSampled(operation: string, tags: any): boolean;
+    onCreateSpan(span: opentracing.Span): SamplingDecision;
+    onSetOperationName(span: opentracing.Span, operationName: string): SamplingDecision;
+    onSetTag(span: opentracing.Span, key: string, value: any): SamplingDecision;
+    close(callback: () => void): void
+}

package/src/util/logging.ts

@@ -30,66 +30,66 @@ export interface LogPayload {
 };
 
 export namespace log {
-    export function error(context: LogContext, message: string, error: Error, payload: LogPayload): void;
-    export function error(context: LogContext, message: string, error: Error): void;
+    export function error(context: LogContext, message: string, error: any, payload: LogPayload): void;
+    export function error(context: LogContext, message: string, error: any): void;
     export function error(context: LogContext, message: string, payload: LogPayload): void;
     export function error(context: LogContext, message: string): void;
-    export function error(context: LogContext, error: Error, payload: LogPayload): void;
-    export function error(context: LogContext, error: Error): void;
-    export function error(message: string, error: Error, payload: LogPayload): void;
-    export function error(message: string, error: Error): void;
+    export function error(context: LogContext, error: any, payload: LogPayload): void;
+    export function error(context: LogContext, error: any): void;
+    export function error(message: string, error: any, payload: LogPayload): void;
+    export function error(message: string, error: any): void;
     export function error(message: string, payload: LogPayload): void;
     export function error(message: string): void;
-    export function error(error: Error, payload: LogPayload): void;
-    export function error(error: Error): void;
+    export function error(error: any, payload: LogPayload): void;
+    export function error(error: any): void;
     export function error(...args: any[]): void {
         errorLog(false, args);
     }
 
-    export function warn(context: LogContext, message: string, error: Error, payload: LogPayload): void;
-    export function warn(context: LogContext, message: string, error: Error): void;
+    export function warn(context: LogContext, message: string, error: any, payload: LogPayload): void;
+    export function warn(context: LogContext, message: string, error: any): void;
     export function warn(context: LogContext, message: string, payload: LogPayload): void;
     export function warn(context: LogContext, message: string): void;
-    export function warn(context: LogContext, error: Error, payload: LogPayload): void;
-    export function warn(context: LogContext, error: Error): void;
-    export function warn(message: string, error: Error, payload: LogPayload): void;
-    export function warn(message: string, error: Error): void;
+    export function warn(context: LogContext, error: any, payload: LogPayload): void;
+    export function warn(context: LogContext, error: any): void;
+    export function warn(message: string, error: any, payload: LogPayload): void;
+    export function warn(message: string, error: any): void;
     export function warn(message: string, payload: LogPayload): void;
     export function warn(message: string): void;
-    export function warn(error: Error, payload: LogPayload): void;
-    export function warn(error: Error): void;
+    export function warn(error: any, payload: LogPayload): void;
+    export function warn(error: any): void;
     export function warn(...args: any[]): void {
         warnLog(false, args);
     }
 
-    export function info(context: LogContext, message: string, error: Error, payload: LogPayload): void;
-    export function info(context: LogContext, message: string, error: Error): void;
+    export function info(context: LogContext, message: string, error: any, payload: LogPayload): void;
+    export function info(context: LogContext, message: string, error: any): void;
     export function info(context: LogContext, message: string, payload: LogPayload): void;
     export function info(context: LogContext, message: string): void;
-    export function info(context: LogContext, error: Error, payload: LogPayload): void;
-    export function info(context: LogContext, error: Error): void;
-    export function info(message: string, error: Error, payload: LogPayload): void;
-    export function info(message: string, error: Error): void;
+    export function info(context: LogContext, error: any, payload: LogPayload): void;
+    export function info(context: LogContext, error: any): void;
+    export function info(message: string, error: any, payload: LogPayload): void;
+    export function info(message: string, error: any): void;
     export function info(message: string, payload: LogPayload): void;
     export function info(message: string): void;
-    export function info(error: Error, payload: LogPayload): void;
-    export function info(error: Error): void;
+    export function info(error: any, payload: LogPayload): void;
+    export function info(error: any): void;
     export function info(...args: any[]): void {
         infoLog(false, args);
     }
 
-    export function debug(context: LogContext, message: string, error: Error, payload: LogPayload): void;
-    export function debug(context: LogContext, message: string, error: Error): void;
+    export function debug(context: LogContext, message: string, error: any, payload: LogPayload): void;
+    export function debug(context: LogContext, message: string, error: any): void;
     export function debug(context: LogContext, message: string, payload: LogPayload): void;
     export function debug(context: LogContext, message: string): void;
-    export function debug(context: LogContext, error: Error, payload: LogPayload): void;
-    export function debug(context: LogContext, error: Error): void;
-    export function debug(message: string, error: Error, payload: LogPayload): void;
-    export function debug(message: string, error: Error): void;
+    export function debug(context: LogContext, error: any, payload: LogPayload): void;
+    export function debug(context: LogContext, error: any): void;
+    export function debug(message: string, error: any, payload: LogPayload): void;
+    export function debug(message: string, error: any): void;
     export function debug(message: string, payload: LogPayload): void;
     export function debug(message: string): void;
-    export function debug(error: Error, payload: LogPayload): void;
-    export function debug(error: Error): void;
+    export function debug(error: any, payload: LogPayload): void;
+    export function debug(error: any): void;
     export function debug(...args: any[]): void {
         debugLog(false, args);
     }
@@ -125,14 +125,8 @@ export namespace log {
 
         // set/unset log functions based on loglevel so we only have to evaluate once, not every call
         const noop = () => {};
-        const setLog = (logFunc: (calleViaConsole: boolean, args: any[]) => void, funcLvl: LogrusLogLevel): (() => void) => {
-            if (LogrusLogLevel.isGreatherOrEqual(funcLvl, logLevel)) {
-                return function (...args: any[]): void {
-                    logFunc(true, args);
-                };
-            } else {
-                return noop;
-            }
+        const setLog = (logFunc: DoLogFunction, funcLevel: LogrusLogLevel): DoLogFunction => {
+            return LogrusLogLevel.isGreatherOrEqual(funcLevel, logLevel) ? logFunc : noop;
         };
 
         errorLog = setLog(doErrorLog, "error");
@@ -156,6 +150,8 @@ export namespace log {
     }
 }
 
+type DoLogFunction = (calledViaConsole: boolean, args: any[]) => void;
+
 let errorLog = doErrorLog;
 function doErrorLog(calledViaConsole: boolean, args: any[]): void {
     doLog(calledViaConsole, errorConsoleLog, 'ERROR', args);
@@ -312,7 +308,6 @@ function makeLogItem(severity: GoogleLogSeverity, context: LogContext | undefine
         severity,
         time: new Date().toISOString(),
         environment: process.env.KUBE_STAGE,
-        region: process.env.GITPOD_REGION,
         context,
         message,
         error,

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

@@ -6,7 +6,7 @@
 
 import * as chai from 'chai';
 import { suite, test } from 'mocha-typescript';
-import { parseWorkspaceIdFromHostname } from './parse-workspace-id';
+import { matchesInstanceIdOrLegacyWorkspaceIdExactly, matchesNewWorkspaceIdExactly, parseWorkspaceIdFromHostname } from './parse-workspace-id';
 const expect = chai.expect;
 
 @suite
@@ -52,5 +52,25 @@ export class ParseWorkspaceIdTest {
         const actual = parseWorkspaceIdFromHostname("webview-3000-ca81a50f-09d7-465c-acd9-264a747d5351.ws-eu01.some.subdomain.somehost.com");
         expect(actual).to.equal("ca81a50f-09d7-465c-acd9-264a747d5351");
     }
+
+    // match - instance ID
+    @test public matchesInstanceIdOrLegacyWorkspaceIdExactly_positive() {
+        const actual = matchesInstanceIdOrLegacyWorkspaceIdExactly("b7e0eaf8-ec73-44ec-81ea-04859263b656");
+        expect(actual).to.be.true;
+    }
+    @test public matchesInstanceIdOrLegacyWorkspaceIdExactly_negative() {
+        const actual = matchesInstanceIdOrLegacyWorkspaceIdExactly("b7e0eaf8-ec73-44ec-81a-04859263b656");
+        expect(actual).to.be.false;
+    }
+
+    // match - new workspace ID
+    @test public matchesWorkspaceIdExactly_new_positive() {
+        const actual = matchesNewWorkspaceIdExactly("moccasin-ferret-155799b3");
+        expect(actual).to.be.true;
+    }
+    @test public matchesWorkspaceIdExactly_new_negative() {
+        const actual = matchesNewWorkspaceIdExactly("moccasin-ferret-15599b3");
+        expect(actual).to.be.false;
+    }
 }
 module.exports = new ParseWorkspaceIdTest()

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

@@ -4,6 +4,14 @@
  * 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}/;
+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:
@@ -13,17 +21,35 @@
  * @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 = /([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8})\.ws/g;
-    const match = wsIdExpression.exec(hostname);
+    const match = REGEX_WORKSPACE_ID_FROM_HOSTNAME.exec(hostname);
     if (match && match.length >= 2) {
         return match[1];
     } else {
-        const legacyUrlFormat = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.ws/g;
-        const legacyMatch = legacyUrlFormat.exec(hostname);
+        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/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/tracing.spec.ts

@@ -0,0 +1,83 @@
+/**
+ * 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()