@gitpod/gitpod-protocol 0.1.5-wth-update-mysql-dependencies-2.31 → 0.1.5-wth-test.80

package/src/teams-projects-protocol.ts

@@ -0,0 +1,147 @@
+/**
+ * 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 { PrebuiltWorkspaceState } from "./protocol";
+import { v4 as uuidv4 } from 'uuid';
+import { DeepPartial } from "./util/deep-partial";
+
+export interface ProjectConfig {
+    '.gitpod.yml': string;
+}
+
+export interface ProjectSettings {
+    useIncrementalPrebuilds?: boolean;
+}
+
+export interface Project {
+    id: string;
+    name: string;
+    slug?: string;
+    cloneUrl: string;
+    teamId?: string;
+    userId?: string;
+    appInstallationId: string;
+    config?: ProjectConfig;
+    settings?: ProjectSettings;
+    creationTime: string;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+    markedDeleted?: boolean;
+}
+
+export namespace Project {
+    export const create = (project: Omit<Project, 'id' | 'creationTime'>): Project => {
+        return {
+            ...project,
+            id: uuidv4(),
+            creationTime: new Date().toISOString()
+        };
+    }
+
+    export interface Overview {
+        branches: BranchDetails[];
+    }
+
+    export namespace Overview {
+        export function is(data?: any): data is Project.Overview {
+            return Array.isArray(data?.branches);
+        }
+    }
+
+    export interface BranchDetails {
+        name: string;
+        url: string;
+        isDefault: boolean;
+
+        // Latest commit
+        changeTitle: string;
+        changeDate?: string;
+        changeAuthor?: string;
+        changeAuthorAvatar?: string;
+        changePR?: string;
+        changeUrl?: string;
+        changeHash: string;
+    }
+}
+
+export type PartialProject = DeepPartial<Project> & Pick<Project, 'id'>;
+
+export interface PrebuildWithStatus {
+    info: PrebuildInfo;
+    status: PrebuiltWorkspaceState;
+    error?: string;
+}
+
+export interface PrebuildInfo {
+    id: string;
+    buildWorkspaceId: string;
+    basedOnPrebuildId?: string;
+
+    teamId?: string;
+    userId?: string;
+
+    projectId: string;
+    projectName: string;
+
+    cloneUrl: string;
+    branch: string;
+
+    startedAt: string;
+    startedBy: string;
+    startedByAvatar?: string;
+
+    changeTitle: string;
+    changeDate: string;
+    changeAuthor: string;
+    changeAuthorAvatar?: string;
+    changePR?: string;
+    changeUrl?: string;
+    changeHash: string;
+}
+export namespace PrebuildInfo {
+    export function is(data?: any): data is PrebuildInfo {
+        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every(p => p in data);
+    }
+}
+
+export interface StartPrebuildResult {
+    prebuildId: string;
+    wsid: string;
+    done: boolean;
+}
+
+export interface Team {
+    id: string;
+    name: string;
+    slug: string;
+    creationTime: string;
+    markedDeleted?: boolean;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}
+
+export type TeamMemberRole = "owner" | "member";
+
+export interface TeamMemberInfo {
+    userId: string;
+    fullName?: string;
+    primaryEmail?: string;
+    avatarUrl?: string;
+    role: TeamMemberRole;
+    memberSince: string;
+}
+
+export interface TeamMembershipInvite {
+    id: string;
+    teamId: string;
+    role: TeamMemberRole;
+    creationTime: string;
+    invalidationTime: string;
+    invitedEmail?: string;
+
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}

package/src/util/analytics.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 Analytics = require("analytics-node");
+import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
+import { log } from './logging';
+
+
+export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
+    switch (process.env.GITPOD_ANALYTICS_WRITER) {
+        case "segment":
+            return new SegmentAnalyticsWriter(process.env.GITPOD_ANALYTICS_SEGMENT_KEY || "");
+        case "log":
+            return new LogAnalyticsWriter();
+        default:
+            return new NoAnalyticsWriter();
+    }
+}
+
+class SegmentAnalyticsWriter implements IAnalyticsWriter {
+
+    protected readonly analytics: Analytics;
+
+    constructor(writeKey: string) {
+        this.analytics = new Analytics(writeKey);
+    }
+
+        identify(msg: IdentifyMessage) {
+        try {
+            this.analytics.identify({
+                ...msg,
+                integrations: {
+                    "All": true,
+                    "Mixpanel": !!msg.userId
+                }
+            }, (err: Error) => {
+                if (err) {
+                    log.warn("analytics.identify failed", err);
+                }
+            });
+        } catch (err) {
+            log.warn("analytics.identify failed", err);
+        }
+    }
+
+    track(msg: TrackMessage) {
+        try {
+            this.analytics.track({
+                ...msg,
+                integrations: {
+                    "All": true,
+                    "Mixpanel": !!msg.userId
+                }
+            }, (err: Error) => {
+                if (err) {
+                    log.warn("analytics.track failed", err);
+                }
+            });
+        } catch (err) {
+            log.warn("analytics.track failed", err);
+        }
+    }
+
+    page(msg: PageMessage) {
+        try{
+            this.analytics.page({
+                ...msg,
+                integrations: {
+                    "All": true,
+                    "Mixpanel": !!msg.userId
+                }
+            }, (err: Error) => {
+                if (err) {
+                    log.warn("analytics.page failed", err);
+                }
+            });
+        } catch (err) {
+            log.warn("analytics.page failed", err);
+        }
+    }
+
+}
+
+class LogAnalyticsWriter implements IAnalyticsWriter {
+
+    identify(msg: IdentifyMessage): void {
+        log.debug("analytics identify", msg);
+    }
+    track(msg: TrackMessage): void {
+        log.debug("analytics track", msg);
+    }
+    page(msg: PageMessage): void {
+        log.debug("analytics page", msg);
+    }
+
+}
+
+class NoAnalyticsWriter implements IAnalyticsWriter {
+    identify(msg: IdentifyMessage): void {}
+    track(msg: TrackMessage): void {}
+    page(msg: PageMessage): void {}
+}

package/src/util/deferred.ts

@@ -19,7 +19,7 @@ export class Deferred<T> {
     promise = new Promise<T>((resolve, reject) => {
         this.resolve = (o) => {
             this.isResolved = true;
-            resolve(o)
+            resolve(o as any)
             clearTimeout(this.timer)
         };
         this.reject = (e) => {

package/src/util/garbage-collected-cache.ts

@@ -4,6 +4,8 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
+import { repeat } from "./repeat";
+
 
 interface CacheEntry<T> {
     key: string;
@@ -13,13 +15,13 @@ interface CacheEntry<T> {
 
 export class GarbageCollectedCache<T> {
     protected readonly store = new Map<string, CacheEntry<T>>();
-    
+
     constructor(
         protected readonly defaultMaxAgeSeconds: number,
         protected readonly gcIntervalSeconds: number) {
         this.regularlyCollectGarbage();
     }
-    
+
     public set(key: string, value: T) {
         const oldValue = this.store.get(key);
         if (oldValue) {
@@ -41,8 +43,12 @@ export class GarbageCollectedCache<T> {
         return entry.value;
     }
 
+    public delete(key: string) {
+        this.store.delete(key);
+    }
+
     protected regularlyCollectGarbage() {
-        setInterval(() => this.collectGarbage(), this.gcIntervalSeconds * 1000);
+        repeat(() => this.collectGarbage(), this.gcIntervalSeconds * 1000);
     }
 
     protected collectGarbage() {

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

@@ -7,7 +7,7 @@
 import { suite, test } from "mocha-typescript"
 import * as chai from "chai"
 import { generateWorkspaceID, colors, animals } from "./generate-workspace-id";
-import { workspaceIDRegex } from "./gitpod-host-url";
+import { GitpodHostUrl } from "./gitpod-host-url";
 
 const expect = chai.expect
 
@@ -15,8 +15,8 @@ const expect = chai.expect
 
     @test public async testGenerateWorkspaceId() {
         for (let i = 0; i < 100; i++) {
-            const name = await generateWorkspaceID();
-            expect(workspaceIDRegex.test(name), name).to.be.true;
+            const id = await generateWorkspaceID();
+            expect(new GitpodHostUrl().withWorkspacePrefix(id, "eu").workspaceId).to.equal(id);
         }
     }
 
@@ -27,5 +27,22 @@ const expect = chai.expect
         expect(longestName.length <= 36, `"${longestName}" is longer than 36 chars (${longestName.length})`).to.be.true;
     }
 
+    @test public async testCustomName() {
+        const data = [
+            ['foo','bar','foo-bar-'],
+            ['f','bar','.{2,16}-bar-'],
+            ['gitpod-io','gitpod','gitpodio-gitpod-'],
+            ['this is rather long and has some "§$"% special chars','also here pretty long and needs abbreviation','thisisratherlon-alsohere-'],
+            ['breatheco-de', 'python-flask-api-tutorial', 'breathecode-pythonflaska-'],
+            ['UPPER', "CaSe", "upper-case-"]
+        ]
+        for (const d of data) {
+            const id = await generateWorkspaceID(d[0], d[1]);
+            expect(id).match(new RegExp("^"+d[2]));
+            expect(new GitpodHostUrl().withWorkspacePrefix(id, "eu").workspaceId).to.equal(id);
+            expect(id.length <= 36, `"${id}" is longer than 36 chars (${id.length})`).to.be.true;
+        }
+    }
+
 }
 module.exports = new TestGenerateWorkspaceId()

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

@@ -5,8 +5,26 @@
  */
 import randomNumber = require("random-number-csprng");
 
-export async function generateWorkspaceID(): Promise<string> {
-    return (await random(colors))+'-'+(await random(animals))+'-'+(await random(characters, 8));
+export async function generateWorkspaceID(firstSegment?: string, secondSegment?: string): Promise<string> {
+    const firstSeg = clean(firstSegment) || await random(colors);
+    const secSeg = clean(secondSegment, Math.min(15, 23 - firstSeg.length)) || await random(animals);
+    return firstSeg+'-'+secSeg+'-'+(await random(characters, 11));
+}
+
+function clean(segment: string | undefined, maxChars: number = 15) {
+  if (!segment) {
+    return undefined;
+  }
+  segment = segment.toLowerCase();
+  let result = '';
+  for (let i =0; i < segment.length; i++) {
+    if (characters.indexOf(segment[i]) !== -1) {
+      result += segment[i];
+    }
+  }
+  if (result.length >= 2) {
+    return result.substring(0, maxChars);
+  }
 }
 
 async function random(array: string[], length: number = 1): Promise<string> {
@@ -48,6 +66,7 @@ export const colors = [
     'indigo',
     'ivory',
     'jade',
+    'kumquat',
     'lavender',
     'lime',
     'magenta',
@@ -172,6 +191,7 @@ export const colors = [
     'deer',
     'dingo',
     'dinosaur',
+    'dodo',
     'dog',
     'dolphin',
     'donkey',

package/src/util/gitpod-cookie.ts

@@ -0,0 +1,39 @@
+/**
+ * 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,5 +1,5 @@
 /**
- * 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.
  */
@@ -21,5 +21,29 @@ export class GitpodHostUrlTest {
         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()

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

@@ -12,8 +12,13 @@ export interface UrlChange {
 }
 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(`^${baseWorkspaceIDRegex}$`);
+
+// this pattern matches URL prefixes of workspaces
+const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${baseWorkspaceIDRegex}\\.`);
 
 export class GitpodHostUrl {
     readonly url: URL;
@@ -44,7 +49,7 @@ export class GitpodHostUrl {
     }
 
     withoutWorkspacePrefix(): GitpodHostUrl {
-        if (!this.url.host.match(workspaceIDRegex)) {
+        if (!this.url.host.match(workspaceUrlPrefixRegex)) {
             // URL has no workspace prefix
             return this;
         }
@@ -80,27 +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: '/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 {
@@ -128,9 +133,13 @@ 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("/")
@@ -141,7 +150,7 @@ export class GitpodHostUrl {
         return undefined;
     }
 
-    get blobServe(): boolean {
+    get blobServe(): boolean {
         const hostSegments = this.url.host.split(".");
         if (hostSegments[0] === 'blobserve') {
             return true;

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