@gitpod/gitpod-protocol 0.1.5-v0.6.0-beta4 → 0.1.5-vn-6525.75

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

@@ -4,29 +4,36 @@
  * 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>;
 
-export const workspaceIDRegex = /([a-z0-9]{4,8}-)+([a-z0-9]{12})/;
+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(`^${baseWorkspaceIDRegex}$`);
+
+// this pattern matches URL prefixes of workspaces
+const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${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 });
         }
     }
 
@@ -39,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;
         }
@@ -52,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);
@@ -67,50 +74,53 @@ 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 }));
+        return this.with((url) => ({ hash: contextUrl }));
     }
 
     asWebsocket(): GitpodHostUrl {
-        return this.with(url => ({ protocol: url.protocol === 'https:' ? 'wss:' : 'ws:' }));
+        return this.with((url) => ({ protocol: url.protocol === "https:" ? "wss:" : "ws:" }));
     }
 
     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: '/upgrade-subscription/' }));
+        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" : "" }));
+        return this.with((url) => ({
+            pathname: `/api/auth/workspace-cookie/${instanceID}`,
+            search: redirect ? "redirect" : "",
+        }));
     }
 
     toString() {
@@ -119,7 +129,7 @@ export class GitpodHostUrl {
 
     toStringWoRootSlash() {
         let result = this.toString();
-        if (result.endsWith('/')) {
+        if (result.endsWith("/")) {
             result = result.slice(0, result.length - 1);
         }
         return result;
@@ -127,12 +137,16 @@ export class GitpodHostUrl {
 
     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[0];
+            }
         }
 
-        const pathSegs = this.url.pathname.split("/")
+        const pathSegs = this.url.pathname.split("/");
         if (pathSegs.length > 3 && pathSegs[1] === "workspace") {
             return pathSegs[2];
         }
@@ -140,18 +154,21 @@ export class GitpodHostUrl {
         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/" }));
+    }
 }

package/src/util/grpc.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+
+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,
+};

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;
+}