@gitpod/gitpod-protocol 0.1.5-main.646 → 0.1.5-main.6462

package/src/util/gitpod-cookie.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 * as cookie from "cookie";
+
+/**
+ * This cookie indicates whether the connected client is a Gitpod user (= "has logged in within the last year") or not.
+ * This is used by "gitpod.io" and "www.gitpod.io" to display different content/buttons.
+ */
+export const NAME = "gitpod-user";
+export const VALUE = "true";
+
+/**
+ * @param domain The domain the Gitpod installation is installed onto
+ * @returns
+ */
+export function options(domain: string): cookie.CookieSerializeOptions {
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies
+    return {
+        path: "/", // make sure we send the cookie to all sub-pages
+        httpOnly: false,
+        secure: false,
+        maxAge: 60 * 60 * 24 * 365, // 1 year
+        sameSite: "lax", // default: true. "Lax" needed to ensure we see cookies from users that neavigate to gitpod.io from external sites
+        domain: `.${domain}`, // explicilty include subdomains to not only cover "gitpod.io", but also "www.gitpod.io" or workspaces
+    };
+}
+
+export function generateCookie(domain: string): string {
+    return cookie.serialize(NAME, VALUE, options(domain));
+}
+
+export function isPresent(cookies: string): boolean {
+    // needs to match the old (gitpod-user=loggedIn) and new (gitpod-user=true) values to ensure a smooth transition during rollout.
+    return !!cookies.match(`${NAME}=`);
+}

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

@@ -1,25 +1,76 @@
 /**
  * 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 { GitpodHostUrl } from './gitpod-host-url';
+import * as chai from "chai";
+import { suite, test } from "mocha-typescript";
+import { GitpodHostUrl } from "./gitpod-host-url";
 const expect = chai.expect;
 
 @suite
 export class GitpodHostUrlTest {
-
     @test public parseWorkspaceId_pathBased() {
-        const actual = GitpodHostUrl.fromWorkspaceUrl("http://35.223.201.195/workspace/bc77e03d-c781-4235-bca0-e24087f5e472/").workspaceId;
+        const actual = GitpodHostUrl.fromWorkspaceUrl(
+            "http://35.223.201.195/workspace/bc77e03d-c781-4235-bca0-e24087f5e472/",
+        ).workspaceId;
         expect(actual).to.equal("bc77e03d-c781-4235-bca0-e24087f5e472");
     }
 
     @test public parseWorkspaceId_hosts_withEnvVarsInjected() {
-        const actual = GitpodHostUrl.fromWorkspaceUrl("https://gray-grasshopper-nfbitfia.ws-eu02.gitpod-staging.com/#passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo").workspaceId;
+        const actual = GitpodHostUrl.fromWorkspaceUrl(
+            "https://gray-grasshopper-nfbitfia.ws-eu02.gitpod-staging.com/#passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo",
+        ).workspaceId;
         expect(actual).to.equal("gray-grasshopper-nfbitfia");
     }
+
+    @test public async testWithoutWorkspacePrefix() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl("https://3000-moccasin-ferret-155799b3.ws-eu02.gitpod-staging.com/")
+                .withoutWorkspacePrefix()
+                .toString(),
+        ).to.equal("https://gitpod-staging.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix2() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl("https://gitpod-staging.com/").withoutWorkspacePrefix().toString(),
+        ).to.equal("https://gitpod-staging.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix3() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl("https://gray-rook-5523v5d8.ws-dev.my-branch-1234.staging.gitpod-dev.com/")
+                .withoutWorkspacePrefix()
+                .toString(),
+        ).to.equal("https://my-branch-1234.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix4() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl("https://my-branch-1234.staging.gitpod-dev.com/")
+                .withoutWorkspacePrefix()
+                .toString(),
+        ).to.equal("https://my-branch-1234.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix5() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl("https://abc-nice-brunch-4224.staging.gitpod-dev.com/")
+                .withoutWorkspacePrefix()
+                .toString(),
+        ).to.equal("https://abc-nice-brunch-4224.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix6() {
+        expect(
+            GitpodHostUrl.fromWorkspaceUrl(
+                "https://gray-rook-5523v5d8.ws-dev.abc-nice-brunch-4224.staging.gitpod-dev.com/",
+            )
+                .withoutWorkspacePrefix()
+                .toString(),
+        ).to.equal("https://abc-nice-brunch-4224.staging.gitpod-dev.com/");
+    }
 }
-module.exports = new GitpodHostUrlTest()
+module.exports = new GitpodHostUrlTest();

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

@@ -1,33 +1,39 @@
 /**
  * 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 URL = require('url').URL || window.URL;
-import { log } from './logging';
+const URL = require("url").URL || window.URL;
+import { log } from "./logging";
 
 export interface UrlChange {
-    (old: URL): Partial<URL>
+    (old: URL): Partial<URL>;
 }
 export type UrlUpdate = UrlChange | Partial<URL>;
 
+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)
-export const workspaceIDRegex = /(([0-9a-f]{8}-[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 workspaceIDRegex = RegExp(`^(?:debug-)?${baseWorkspaceIDRegex}$`);
+
+// this pattern matches URL prefixes of workspaces
+const workspaceUrlPrefixRegex = RegExp(`^(([0-9]{4,6}|debug)-)?${baseWorkspaceIDRegex}\\.`);
 
 export class GitpodHostUrl {
     readonly url: URL;
 
     constructor(urlParam?: string | URL) {
-        if (urlParam === undefined || typeof urlParam === 'string') {
-            this.url = new URL(urlParam || 'https://gitpod.io');
-            this.url.search = '';
-            this.url.hash = '';
-            this.url.pathname = '';
+        if (urlParam === undefined || typeof urlParam === "string") {
+            this.url = new URL(urlParam || "https://gitpod.io");
+            this.url.search = "";
+            this.url.hash = "";
+            this.url.pathname = "";
         } else if (urlParam instanceof URL) {
             this.url = urlParam;
         } else {
-            log.error('Unexpected urlParam', { urlParam });
+            log.error("Unexpected urlParam", { urlParam });
         }
     }
 
@@ -40,11 +46,11 @@ export class GitpodHostUrl {
     }
 
     withDomainPrefix(prefix: string): GitpodHostUrl {
-        return this.with(url => ({ host: prefix + url.host }));;
+        return this.with((url) => ({ host: prefix + url.host }));
     }
 
     withoutWorkspacePrefix(): GitpodHostUrl {
-        if (!this.url.host.match(workspaceIDRegex)) {
+        if (!this.url.host.match(workspaceUrlPrefixRegex)) {
             // URL has no workspace prefix
             return this;
         }
@@ -53,14 +59,14 @@ export class GitpodHostUrl {
     }
 
     withoutDomainPrefix(removeSegmentsCount: number): GitpodHostUrl {
-        return this.with(url => ({ host: url.host.split('.').splice(removeSegmentsCount).join('.') }));
+        return this.with((url) => ({ host: url.host.split(".").splice(removeSegmentsCount).join(".") }));
     }
 
     with(urlUpdate: UrlUpdate) {
-        const update = typeof urlUpdate === 'function' ? urlUpdate(this.url) : urlUpdate;
-        const addSlashToPath = update.pathname && update.pathname.length > 0 && !update.pathname.startsWith('/');
+        const update = typeof urlUpdate === "function" ? urlUpdate(this.url) : urlUpdate;
+        const addSlashToPath = update.pathname && update.pathname.length > 0 && !update.pathname.startsWith("/");
         if (addSlashToPath) {
-            update.pathname = '/' + update.pathname;
+            update.pathname = "/" + update.pathname;
         }
         const result = Object.assign(new URL(this.toString()), update);
         return new GitpodHostUrl(result);
@@ -68,50 +74,67 @@ export class GitpodHostUrl {
 
     withApi(urlUpdate?: UrlUpdate) {
         const updated = urlUpdate ? this.with(urlUpdate) : this;
-        return updated.with(url => ({ pathname: `/api${url.pathname}` }));
+        return updated.with((url) => ({ pathname: `/api${url.pathname}` }));
     }
 
-    withContext(contextUrl: string) {
-        return this.with(url => ({ hash: contextUrl }));
+    withContext(
+        contextUrl: string,
+        startOptions?: { showOptions?: boolean; editor?: string; workspaceClass?: string },
+    ) {
+        const searchParams = new URLSearchParams();
+        if (startOptions?.showOptions) {
+            searchParams.append("showOptions", "true");
+        }
+        return this.with((url) => ({ hash: contextUrl, search: searchParams.toString() }));
     }
 
     asWebsocket(): GitpodHostUrl {
-        return this.with(url => ({ protocol: url.protocol === 'https:' ? 'wss:' : 'ws:' }));
+        return this.with((url) => ({ protocol: url.protocol === "https:" ? "wss:" : "ws:" }));
+    }
+
+    asWorkspacePage(): GitpodHostUrl {
+        return this.with((url) => ({ pathname: "/workspaces" }));
     }
 
     asDashboard(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/workspaces/' }));
+        return this.with((url) => ({ pathname: "/" }));
+    }
+
+    asBilling(): GitpodHostUrl {
+        return this.with((url) => ({ pathname: "/billing" }));
     }
 
     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" }));
     }
 
-    asGraphQLApi(): GitpodHostUrl {
-        return this.with(url => ({ pathname: '/graphql/' }));
+    asPreferences(): GitpodHostUrl {
+        return this.with((url) => ({ pathname: "/preferences" }));
     }
 
     asStart(workspaceId = this.workspaceId): GitpodHostUrl {
         return this.withoutWorkspacePrefix().with({
-            pathname: '/start/',
-            hash: '#' + workspaceId
+            pathname: "/start/",
+            hash: "#" + workspaceId,
         });
     }
 
-    asWorkspaceAuth(instanceID: string, redirect?: boolean): GitpodHostUrl {
-        return this.with(url => ({ pathname: `/api/auth/workspace-cookie/${instanceID}`, search: redirect ? "redirect" : "" }));
+    asWorkspaceAuth(instanceID: string): GitpodHostUrl {
+        return this.with((url) => ({
+            pathname: `/api/auth/workspace-cookie/${instanceID}`,
+        }));
     }
 
     toString() {
@@ -120,43 +143,72 @@ export class GitpodHostUrl {
 
     toStringWoRootSlash() {
         let result = this.toString();
-        if (result.endsWith('/')) {
+        if (result.endsWith("/")) {
             result = result.slice(0, result.length - 1);
         }
         return result;
     }
 
+    get debugWorkspace(): boolean {
+        return this.url.host.match(workspaceUrlPrefixRegex)?.[2] === "debug";
+    }
+
     get workspaceId(): string | undefined {
         const hostSegs = this.url.host.split(".");
-        if (hostSegs.length > 1 && hostSegs[0].match(workspaceIDRegex)) {
-            // URL has a workspace prefix
-            return hostSegs[0];
+        if (hostSegs.length > 1) {
+            const matchResults = hostSegs[0].match(workspaceIDRegex);
+            if (matchResults) {
+                // URL has a workspace prefix
+                // port prefixes are excluded
+                return matchResults[1];
+            }
         }
 
-        const pathSegs = this.url.pathname.split("/")
+        const pathSegs = this.url.pathname.split("/");
         if (pathSegs.length > 3 && pathSegs[1] === "workspace") {
             return pathSegs[2];
         }
 
+        const cleanHash = this.url.hash.replace(/^#/, "");
+        if (this.url.pathname == "/start/" && cleanHash.match(workspaceIDRegex)) {
+            return cleanHash;
+        }
+
         return undefined;
     }
 
-    get blobServe(): boolean {
+    get blobServe(): boolean {
         const hostSegments = this.url.host.split(".");
-        if (hostSegments[0] === 'blobserve') {
+        if (hostSegments[0] === "blobserve") {
             return true;
         }
 
-        const pathSegments = this.url.pathname.split("/")
+        const pathSegments = this.url.pathname.split("/");
         return pathSegments[0] === "blobserve";
     }
 
     asSorry(message: string) {
-        return this.with({ pathname: '/sorry', hash: message });
+        return this.with({ pathname: "/sorry", hash: message });
     }
 
     asApiLogout(): GitpodHostUrl {
-        return this.withApi(url => ({ pathname: '/logout/' }));
+        return this.withApi((url) => ({ pathname: "/logout/" }));
     }
 
+    asIDEProxy(): GitpodHostUrl {
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] === "ide") {
+            return this;
+        }
+        return this.with((url) => ({ host: "ide." + url.host }));
+    }
+
+    asIDEMetrics(): GitpodHostUrl {
+        let newUrl: GitpodHostUrl = this;
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] !== "ide") {
+            newUrl = newUrl.asIDEProxy();
+        }
+        return newUrl.with((url) => ({ pathname: "/metrics-api" }));
+    }
 }

package/src/util/grpc.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 * as grpc from "@grpc/grpc-js";
+import { Status } from "@grpc/grpc-js/build/src/constants";
+
+export const defaultGRPCOptions = {
+    "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,
+    "grpc.max_receive_message_length": 1024 * 1024 * 16,
+};
+
+export type GrpcMethodType = "unary" | "client_stream" | "server_stream" | "bidi_stream";
+
+export interface IGrpcCallMetricsLabels {
+    service: string;
+    method: string;
+    type: GrpcMethodType;
+}
+
+export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
+    code: string;
+}
+
+export const IClientCallMetrics = Symbol("IClientCallMetrics");
+
+export interface IClientCallMetrics {
+    started(labels: IGrpcCallMetricsLabels): void;
+    sent(labels: IGrpcCallMetricsLabels): void;
+    received(labels: IGrpcCallMetricsLabels): void;
+    handled(labels: IGrpcCallMetricsLabelsWithCode): void;
+    startHandleTimer(
+        labels: IGrpcCallMetricsLabels,
+    ): (labels?: Partial<Record<string, string | number>> | undefined) => number;
+}
+
+export function getGrpcMethodType(requestStream: boolean, responseStream: boolean): GrpcMethodType {
+    if (requestStream) {
+        if (responseStream) {
+            return "bidi_stream";
+        } else {
+            return "client_stream";
+        }
+    } else {
+        if (responseStream) {
+            return "server_stream";
+        } else {
+            return "unary";
+        }
+    }
+}
+
+export function createClientCallMetricsInterceptor(metrics: IClientCallMetrics): grpc.Interceptor {
+    return (options, nextCall): grpc.InterceptingCall => {
+        const methodDef = options.method_definition;
+        const method = methodDef.path.substring(methodDef.path.lastIndexOf("/") + 1);
+        const service = methodDef.path.substring(1, methodDef.path.length - method.length - 1);
+        const labels = {
+            service,
+            method,
+            type: getGrpcMethodType(options.method_definition.requestStream, options.method_definition.responseStream),
+        };
+        const requester = new grpc.RequesterBuilder()
+            .withStart((metadata, listener, next) => {
+                const newListener = new grpc.ListenerBuilder()
+                    .withOnReceiveStatus((status, next) => {
+                        try {
+                            metrics.handled({
+                                ...labels,
+                                code: Status[status.code],
+                            });
+                        } finally {
+                            next(status);
+                        }
+                    })
+                    .withOnReceiveMessage((message, next) => {
+                        try {
+                            metrics.received(labels);
+                        } finally {
+                            next(message);
+                        }
+                    })
+                    .build();
+                try {
+                    metrics.started(labels);
+                } finally {
+                    next(metadata, newListener);
+                }
+            })
+            .withSendMessage((message, next) => {
+                try {
+                    metrics.sent(labels);
+                } finally {
+                    next(message);
+                }
+            })
+            .build();
+        return new grpc.InterceptingCall(nextCall(options), requester);
+    };
+}

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.spec.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { log } from "./logging";
+
+@suite
+class TestLogging {
+    @test public async testLogInfo_output() {
+        const testObj = {
+            null: null,
+            undefined: undefined,
+            empty: "",
+            foo: "bar",
+            number: 0,
+        };
+        log.info("info logging test", testObj);
+    }
+}
+module.exports = new TestLogging();