@gitpod/gitpod-protocol 0.1.5-main.648 → 0.1.5-main.6480

package/src/util/logging.ts

@@ -1,11 +1,12 @@
 /**
  * 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 inspect: (object: any) => string = require('util').inspect;   // undefined in frontend
+const inspect: (object: any) => string = require("util").inspect; // undefined in frontend
 
+let plainLogging: boolean = false; // set to true during development to get non JSON output
 let jsonLogging: boolean = false;
 let component: string | undefined;
 let version: string | undefined;
@@ -15,81 +16,81 @@ export interface LogContext {
     sessionId?: string;
     userId?: string;
     workspaceId?: string;
-};
+}
 export namespace LogContext {
-    export function from(params : { userId?: string, user?: any, request?: any } ) {
+    export function from(params: { userId?: string; user?: any; request?: any }) {
         return <LogContext>{
             sessionId: params.request?.requestID,
-            userId: params.userId || params.user?.id
-        }
+            userId: params.userId || params.user?.id,
+        };
     }
 }
 
 export interface LogPayload {
     // placeholder to indicate that only dictionary-style objects should be passed as payload
-};
+}
 
 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);
     }
@@ -97,26 +98,46 @@ export namespace log {
     /**
      * Do not use in frontend.
      */
-    export function enableJSONLogging(componentArg: string, versionArg: string | undefined): void {
+    export function enableJSONLogging(
+        componentArg: string,
+        versionArg: string | undefined,
+        logLevel?: LogrusLogLevel,
+    ): void {
         component = componentArg;
         version = versionArg;
 
+        setLogLevel(logLevel);
+    }
+
+    export function setLogLevel(logLevel: LogrusLogLevel | undefined) {
         jsonLogging = true;
 
         console.error = function (...args: any[]): void {
             errorLog(true, args);
-        }
+        };
         console.warn = function (...args: any[]): void {
             warnLog(true, args);
-        }
+        };
         console.info = function (...args: any[]): void {
             infoLog(true, args);
-        }
+        };
         console.debug = function (...args: any[]): void {
             debugLog(true, args);
-        }
+        };
+
         console.log = console.info;
         // FIXME wrap also other console methods (e.g. trace())
+
+        // set/unset log functions based on loglevel so we only have to evaluate once, not every call
+        const noop = () => {};
+        const setLog = (logFunc: DoLogFunction, funcLevel: LogrusLogLevel): DoLogFunction => {
+            return LogrusLogLevel.isGreatherOrEqual(funcLevel, logLevel) ? logFunc : noop;
+        };
+
+        errorLog = setLog(doErrorLog, "error");
+        warnLog = setLog(doWarnLog, "warning");
+        infoLog = setLog(doInfoLog, "info");
+        debugLog = setLog(doDebugLog, "debug");
     }
 
     export function resetToDefaultLogging(): void {
@@ -128,31 +149,79 @@ export namespace log {
         console.info = infoConsoleLog;
         console.debug = debugConsoleLog;
     }
+
+    export function setVersion(versionArg: string) {
+        version = versionArg;
+    }
 }
 
-function errorLog(calledViaConsole: boolean, args: any[]): void {
-    doLog(calledViaConsole, errorConsoleLog, 'ERROR', args);
+type DoLogFunction = (calledViaConsole: boolean, args: any[]) => void;
+
+let errorLog = doErrorLog;
+function doErrorLog(calledViaConsole: boolean, args: any[]): void {
+    doLog(calledViaConsole, errorConsoleLog, "ERROR", args);
 }
 
-function warnLog(calledViaConsole: boolean, args: any[]): void {
-    doLog(calledViaConsole, warnConsoleLog, 'WARNING', args);
+let warnLog = doWarnLog;
+function doWarnLog(calledViaConsole: boolean, args: any[]): void {
+    doLog(calledViaConsole, warnConsoleLog, "WARNING", args);
 }
 
-function infoLog(calledViaConsole: boolean, args: any[]): void {
-    doLog(calledViaConsole, infoConsoleLog, 'INFO', args);
+let infoLog = doInfoLog;
+function doInfoLog(calledViaConsole: boolean, args: any[]): void {
+    doLog(calledViaConsole, infoConsoleLog, "INFO", args);
 }
 
-function debugLog(calledViaConsole: boolean, args: any[]): void {
-    doLog(calledViaConsole, debugConsoleLog, 'DEBUG', args);
+let debugLog = doDebugLog;
+function doDebugLog(calledViaConsole: boolean, args: any[]): void {
+    doLog(calledViaConsole, debugConsoleLog, "DEBUG", args);
+}
+
+// Ref: https://github.com/sirupsen/logrus#level-logging
+export type LogrusLogLevel = keyof typeof LogrusLogLevels;
+export const LogrusLogLevels = {
+    trace: true,
+    debug: true,
+    info: true,
+    warning: true,
+    error: true,
+    fatal: true,
+    panic: true,
+};
+export namespace LogrusLogLevel {
+    export function isGreatherOrEqual(lvl: LogrusLogLevel | undefined, ref: LogrusLogLevel | undefined): boolean {
+        if (lvl === undefined) {
+            return false;
+        }
+        if (ref === undefined) {
+            return true;
+        }
+        return getLevelArity(lvl) >= getLevelArity(ref);
+    }
+    function getLevelArity(lvl: LogrusLogLevel): number {
+        return Object.keys(LogrusLogLevels).findIndex((l) => l === lvl);
+    }
+    export function getFromEnv(): LogrusLogLevel | undefined {
+        const lvlStr = process.env.LOG_LEVEL;
+        if (!lvlStr) {
+            return undefined;
+        }
+        const lvl = lvlStr as LogrusLogLevel;
+        const exists = LogrusLogLevels[lvl];
+        if (!exists) {
+            return undefined;
+        }
+        return lvl;
+    }
 }
 
 // Source: https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
-type GoogleLogSeverity = 'EMERGENCY' | 'ALERT' | 'CRITICAL' | 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+type GoogleLogSeverity = "EMERGENCY" | "ALERT" | "CRITICAL" | "ERROR" | "WARNING" | "INFO" | "DEBUG";
 namespace GoogleLogSeverity {
     export const isGreaterOrEqualThanWarning = (severity: GoogleLogSeverity) => {
         switch (severity) {
-            case 'INFO':
-            case 'DEBUG':
+            case "INFO":
+            case "DEBUG":
                 return false;
             default:
                 return true;
@@ -180,7 +249,7 @@ function doLog(calledViaConsole: boolean, consoleLog: ConsoleLog, severity: Goog
         // console.xyz(Error, ...any) / log.xyz(Error) / log.xyz(Error, LogPayload)
         error = args[0];
         payloadArgs = args.slice(1);
-    } else if (typeof args[0] === 'string') {
+    } else if (typeof args[0] === "string") {
         message = args[0];
         if (args.length < 2 || !(args[1] instanceof Error)) {
             // console.xyz(string) / console.xyz(string, !Error, ...any) / log.xyz(string) / log.xyz(string, LogPayload)
@@ -200,7 +269,7 @@ function doLog(calledViaConsole: boolean, consoleLog: ConsoleLog, severity: Goog
             // log.xyz(LogContext, Error) / log.xyz(LogContext, Error, LogPayload)
             error = args[1];
             payloadArgs = args.slice(2);
-        } else if (typeof args[1] === 'string') {
+        } else if (typeof args[1] === "string") {
             message = args[1];
             if (args.length < 3 || !(args[2] instanceof Error)) {
                 // log.xyz(LogContext, string) / log.xyz(LogContext, string, LogPayload)
@@ -223,9 +292,14 @@ function doLog(calledViaConsole: boolean, consoleLog: ConsoleLog, severity: Goog
     }
 }
 
-function makeLogItem(severity: GoogleLogSeverity, context: LogContext | undefined, message: string | undefined,
-        error: Error | undefined, payloadArgs: any[], calledViaConsole: boolean): string | undefined {
-
+function makeLogItem(
+    severity: GoogleLogSeverity,
+    context: LogContext | undefined,
+    message: string | undefined,
+    error: Error | undefined,
+    payloadArgs: any[],
+    calledViaConsole: boolean,
+): string | undefined {
     if (context !== undefined && Object.keys(context).length == 0) {
         context = undefined;
     }
@@ -236,34 +310,40 @@ function makeLogItem(severity: GoogleLogSeverity, context: LogContext | undefine
     }
 
     const payload: any = payloadArgs.length == 0 ? undefined : payloadArgs.length == 1 ? payloadArgs[0] : payloadArgs;
-    const logItem: any = {
+    const logItem = {
         // undefined fields get eliminated in JSON.stringify()
         ...reportedErrorEvent,
         component,
         severity,
         time: new Date().toISOString(),
-        environment: process.env.KUBE_STAGE,
-        region: process.env.GITPOD_REGION,
         context,
         message,
         error,
         payload,
-        loggedViaConsole: calledViaConsole ? true : undefined
+        loggedViaConsole: calledViaConsole ? true : undefined,
     };
+    if (plainLogging) {
+        return `[${logItem.severity}] [${logItem.component}] ${logItem.message}
+            ${JSON.stringify(payload || "", undefined, "              ")}
+            ${error || ""}
+        `.trim();
+    }
     let result: string = stringifyLogItem(logItem);
 
     if (result.length > maxAllowedLogItemLength && payload !== undefined) {
         delete logItem.payload;
-        logItem.payloadStub = `Payload stripped as log item was longer than ${maxAllowedLogItemLength} characters`;
+        (<any>(
+            logItem
+        )).payloadStub = `Payload stripped as log item was longer than ${maxAllowedLogItemLength} characters`;
 
         result = stringifyLogItem(logItem);
 
         if (result.length <= maxAllowedLogItemLength) {
-            log.warn('Log item too large, stripping payload', { logItemStub: makeLogItemStub(logItem) });
+            log.warn("Log item too large, stripping payload", { logItemStub: makeLogItemStub(logItem) });
         }
     }
     if (result.length > maxAllowedLogItemLength) {
-        log.error('Log item too large w/o payload, discarding', { logItemStub: makeLogItemStub(logItem) });
+        log.error("Log item too large w/o payload, discarding", { logItemStub: makeLogItemStub(logItem) });
         return undefined;
     }
 
@@ -277,10 +357,10 @@ function makeReportedErrorEvent(error: Error | undefined) {
         // Serves as marker only
         "@type": "type.googleapis.com/google.devtools.clouderrorreporting.v1beta1.ReportedErrorEvent",
         // This is useful for filtering in the UI
-        "serviceContext": {
-            "service": component || "<ts-not-set>",
-            "version": version || "<ts-not-set>",
-        }
+        serviceContext: {
+            service: component || "<ts-not-set>",
+            version: version || "<ts-not-set>",
+        },
     };
 
     if (error) {
@@ -300,9 +380,9 @@ function makeLogItemStub(logItem: any): any {
         severity: logItem.severity,
         time: logItem.time,
         environment: logItem.environment,
-        region: logItem.region
+        region: logItem.region,
     };
-    if (typeof (logItem.message) === 'string') {
+    if (typeof logItem.message === "string") {
         if (logItem.message.length <= maxMessageStubLength) {
             result.message = logItem.message;
         } else {
@@ -336,10 +416,12 @@ function stringifyLogItem(logItem: any): string {
  * Jsonifies Errors properly, not as {} only.
  */
 function jsonStringifyWithErrors(value: any): string {
-    return JSON.stringify(value, (key: string, value: any): any => { return value instanceof Error ? value.stack : value });
+    return JSON.stringify(value, (key: string, value: any): any => {
+        return value instanceof Error ? value.stack : value;
+    });
 }
 
-type ConsoleLog = (message?: any, ...optionalArgs: any[]) => void;  // signature of console.xyz
+type ConsoleLog = (message?: any, ...optionalArgs: any[]) => void; // signature of console.xyz
 const logConsoleLog: ConsoleLog = console.log;
 const errorConsoleLog: ConsoleLog = console.error;
 const warnConsoleLog: ConsoleLog = console.warn;

package/src/util/make-link.ts

@@ -1,22 +1,21 @@
 /**
  * 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.
  */
 
 function isOpenNewTab(event: MouseEvent): boolean {
-    return event.metaKey || (event.ctrlKey);
+    return event.metaKey || event.ctrlKey;
 }
 
 export function makeLink(node: HTMLElement, url: string, hover: string): void {
-    node.onclick = event => {
-        let target = '_self';
+    node.onclick = (event) => {
+        let target = "_self";
         if (isOpenNewTab(event)) {
-            target = '_blank';
+            target = "_blank";
         }
         window.open(url, target);
-    }
-    node.style.cursor = 'pointer';
+    };
+    node.style.cursor = "pointer";
     node.title = hover;
 }
-

package/src/util/nice-grpc.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 { isAbortError } from "abort-controller-x";
+import {
+    CallOptions,
+    ClientError,
+    ClientMiddleware,
+    ClientMiddlewareCall,
+    Status,
+    MethodDescriptor,
+} from "nice-grpc-common";
+import { GrpcMethodType, IClientCallMetrics } from "./grpc";
+
+function getLabels(method: MethodDescriptor) {
+    const callType = method.requestStream
+        ? method.responseStream
+            ? "bidi_stream"
+            : "client_stream"
+        : method.responseStream
+        ? "server_stream"
+        : "unary";
+    const { path } = method;
+    const [serviceName, methodName] = path.split("/").slice(1);
+
+    return {
+        type: callType as GrpcMethodType,
+        service: serviceName,
+        method: methodName,
+    };
+}
+
+async function* incrementStreamMessagesCounter<T>(iterable: AsyncIterable<T>, callback: () => void): AsyncIterable<T> {
+    for await (const item of iterable) {
+        callback();
+        yield item;
+    }
+}
+
+export function prometheusClientMiddleware(metrics: IClientCallMetrics): ClientMiddleware {
+    return async function* prometheusClientMiddlewareGenerator<Request, Response>(
+        call: ClientMiddlewareCall<Request, Response>,
+        options: CallOptions,
+    ): AsyncGenerator<Response, Response | void, undefined> {
+        const labels = getLabels(call.method);
+
+        metrics.started(labels);
+
+        const stopTimer = metrics.startHandleTimer(labels);
+
+        let settled = false;
+        let status: Status = Status.OK;
+
+        try {
+            let request;
+
+            if (!call.requestStream) {
+                request = call.request;
+            } else {
+                request = incrementStreamMessagesCounter(call.request, metrics.sent.bind(metrics, labels));
+            }
+
+            if (!call.responseStream) {
+                const response = yield* call.next(request, options);
+                settled = true;
+                return response;
+            } else {
+                yield* incrementStreamMessagesCounter(
+                    call.next(request, options),
+                    metrics.received.bind(metrics, labels),
+                );
+                settled = true;
+                return;
+            }
+        } catch (err) {
+            settled = true;
+            if (err instanceof ClientError) {
+                status = err.code;
+            } else if (isAbortError(err)) {
+                status = Status.CANCELLED;
+            } else {
+                status = Status.UNKNOWN;
+            }
+            throw err;
+        } finally {
+            if (!settled) {
+                status = Status.CANCELLED;
+            }
+            stopTimer({ grpc_code: Status[status] });
+            metrics.handled({ ...labels, code: Status[status] });
+        }
+    };
+}

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

@@ -1,17 +1,20 @@
 /**
  * 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 { suite, test } from 'mocha-typescript';
-import { parseWorkspaceIdFromHostname } from './parse-workspace-id';
+import * as chai from "chai";
+import { suite, test } from "mocha-typescript";
+import {
+    matchesInstanceIdOrLegacyWorkspaceIdExactly,
+    matchesNewWorkspaceIdExactly,
+    parseWorkspaceIdFromHostname,
+} from "./parse-workspace-id";
 const expect = chai.expect;
 
 @suite
 export class ParseWorkspaceIdTest {
-
     @test public parseWorkspaceIdFromHostname_fromWorkspaceLocation() {
         const actual = parseWorkspaceIdFromHostname("moccasin-ferret-155799b3.ws-eu01.gitpod.io");
         expect(actual).to.equal("moccasin-ferret-155799b3");
@@ -28,7 +31,9 @@ export class ParseWorkspaceIdTest {
     }
 
     @test public parseWorkspaceIdFromHostname_fromWorkspacePortLocationWithWebviewPrefixCustomHost() {
-        const actual = parseWorkspaceIdFromHostname("webview-3000-moccasin-ferret-155799b3.ws-eu01.some.subdomain.somehost.com");
+        const actual = parseWorkspaceIdFromHostname(
+            "webview-3000-moccasin-ferret-155799b3.ws-eu01.some.subdomain.somehost.com",
+        );
         expect(actual).to.equal("moccasin-ferret-155799b3");
     }
 
@@ -44,13 +49,37 @@ export class ParseWorkspaceIdTest {
     }
 
     @test public parseLegacyWorkspaceIdFromHostname_fromWorkspacePortLocationWithWebviewPrefix() {
-        const actual = parseWorkspaceIdFromHostname("webview-3000-b7e0eaf8-ec73-44ec-81ea-04859263b656.ws-eu01.gitpod.io");
+        const actual = parseWorkspaceIdFromHostname(
+            "webview-3000-b7e0eaf8-ec73-44ec-81ea-04859263b656.ws-eu01.gitpod.io",
+        );
         expect(actual).to.equal("b7e0eaf8-ec73-44ec-81ea-04859263b656");
     }
 
     @test public parseLegacyWorkspaceIdFromHostname_fromWorkspacePortLocationWithWebviewPrefixCustomHost() {
-        const actual = parseWorkspaceIdFromHostname("webview-3000-ca81a50f-09d7-465c-acd9-264a747d5351.ws-eu01.some.subdomain.somehost.com");
+        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()
+module.exports = new ParseWorkspaceIdTest();

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

@@ -1,9 +1,17 @@
 /**
  * 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:
@@ -12,18 +20,35 @@
  *  - 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 = /([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8})\.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 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);
+};