@gitpod/gitpod-protocol 0.1.5-release-2022.6.1.1 → 0.1.5-release-2022.11.2.5

package/src/teams-projects-protocol.ts

@@ -4,9 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { PrebuiltWorkspaceState } from "./protocol";
+import { PrebuiltWorkspaceState, WorkspaceClasses } from "./protocol";
 import { v4 as uuidv4 } from "uuid";
 import { DeepPartial } from "./util/deep-partial";
+import { WebhookEvent } from "./webhook-event";
 
 export interface ProjectConfig {
     ".gitpod.yml": string;
@@ -16,6 +17,12 @@ export interface ProjectSettings {
     useIncrementalPrebuilds?: boolean;
     usePersistentVolumeClaim?: boolean;
     keepOutdatedPrebuildsRunning?: boolean;
+    // whether new workspaces can start on older prebuilds and incrementally update
+    allowUsingPreviousPrebuilds?: boolean;
+    // how many commits in the commit history a prebuild is good (undefined and 0 means every commit is prebuilt)
+    prebuildEveryNthCommit?: number;
+    // preferred workspace classes
+    workspaceClasses?: WorkspaceClasses;
 }
 
 export interface Project {
@@ -26,7 +33,6 @@ export interface Project {
     teamId?: string;
     userId?: string;
     appInstallationId: string;
-    config?: ProjectConfig;
     settings?: ProjectSettings;
     creationTime: string;
     /** This is a flag that triggers the HARD DELETION of this entity */
@@ -45,6 +51,7 @@ export namespace Project {
 
     export interface Overview {
         branches: BranchDetails[];
+        isConsideredInactive?: boolean;
     }
 
     export namespace Overview {
@@ -119,7 +126,6 @@ export interface StartPrebuildResult {
     wsid: string;
     done: boolean;
 }
-
 export interface Team {
     id: string;
     name: string;
@@ -152,3 +158,15 @@ export interface TeamMembershipInvite {
     /** This is a flag that triggers the HARD DELETION of this entity */
     deleted?: boolean;
 }
+
+export interface PrebuildEvent {
+    id: string;
+    creationTime: string;
+    status: WebhookEvent.Status | WebhookEvent.PrebuildStatus;
+    message?: string;
+    prebuildId?: string;
+    projectId?: string;
+    cloneUrl?: string;
+    branch?: string;
+    commit?: string;
+}

package/src/usage.ts

@@ -6,141 +6,80 @@
 
 import { WorkspaceType } from "./protocol";
 
-export interface BillableSession {
-    // The id of the one paying the bill
+// types below are copied over from components/usage-api/typescript/src/usage/v1/usage_pb.d.ts
+export interface ListUsageRequest {
     attributionId: string;
+    from?: number;
+    to?: number;
+    order: Ordering;
+    pagination?: PaginationRequest;
+}
 
-    // Relevant for workspace type. When prebuild, shows "prebuild"
-    userId?: string;
-    teamId?: string;
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
 
-    instanceId: string;
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
 
-    workspaceId: string;
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditsUsed: number;
+}
 
-    workspaceType: BillableWorkspaceType;
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
+}
 
-    // "standard" or "XL"
-    workspaceClass: string;
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
+    attributionId: string;
+    description: string;
+    credits: number;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
+}
 
-    // When the workspace started
+// the equivalent golang shape is maintained in `/workspace/gitpod/`components/usage/pkg/db/usage.go`
+export interface WorkspaceInstanceUsageData {
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+    workspaceClass: string;
+    contextURL: string;
     startTime: string;
+    endTime?: string;
+    userId: string;
+    userName: string;
+    userAvatarURL: string;
+}
 
-    // When the workspace ended
-    endTime: string;
-
-    // The credits used for this session
-    credits: number;
-
-    // TODO - maybe
-    projectId?: string;
+export interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
 }
 
-export type BillableWorkspaceType = WorkspaceType;
+export interface CostCenterJSON {
+    attributionId: string;
+    spendingLimit: number;
+    billingStrategy: CostCenter_BillingStrategy;
+    nextBillingTime?: string;
+    billingCycleStart?: string;
+}
 
-export const billableSessionDummyData: BillableSession[] = [
-    {
-        attributionId: "some-attribution-id",
-        userId: "prebuild",
-        teamId: "prebuild",
-        instanceId: "some-instance-id",
-        workspaceId: "some-workspace-id",
-        workspaceType: "prebuild",
-        workspaceClass: "XL",
-        startTime: new Date(Date.now() + -3 * 24 * 3600 * 1000).toISOString(), // 3 days ago
-        endTime: new Date().toISOString(),
-        credits: 320,
-        projectId: "project-123",
-    },
-    {
-        attributionId: "some-attribution-id2",
-        userId: "some-user",
-        teamId: "some-team",
-        instanceId: "some-instance-id2",
-        workspaceId: "some-workspace-id2",
-        workspaceType: "regular",
-        workspaceClass: "standard",
-        startTime: new Date(Date.now() + -5 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date().toISOString(),
-        credits: 130,
-        projectId: "project-123",
-    },
-    {
-        attributionId: "some-attribution-id3",
-        userId: "some-other-user",
-        teamId: "some-other-team",
-        instanceId: "some-instance-id3",
-        workspaceId: "some-workspace-id3",
-        workspaceType: "regular",
-        workspaceClass: "XL",
-        startTime: new Date(Date.now() + -5 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date(Date.now() + -4 * 24 * 3600 * 1000).toISOString(),
-        credits: 150,
-        projectId: "project-134",
-    },
-    {
-        attributionId: "some-attribution-id4",
-        userId: "some-other-user2",
-        teamId: "some-other-team2",
-        instanceId: "some-instance-id4",
-        workspaceId: "some-workspace-id4",
-        workspaceType: "regular",
-        workspaceClass: "standard",
-        startTime: new Date(Date.now() + -10 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date(Date.now() + -9 * 24 * 3600 * 1000).toISOString(),
-        credits: 330,
-        projectId: "project-137",
-    },
-    {
-        attributionId: "some-attribution-id5",
-        userId: "some-other-user3",
-        teamId: "some-other-team3",
-        instanceId: "some-instance-id5",
-        workspaceId: "some-workspace-id5",
-        workspaceType: "regular",
-        workspaceClass: "XL",
-        startTime: new Date(Date.now() + -2 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date().toISOString(),
-        credits: 222,
-        projectId: "project-138",
-    },
-    {
-        attributionId: "some-attribution-id6",
-        userId: "some-other-user4",
-        teamId: "some-other-team4",
-        instanceId: "some-instance-id6",
-        workspaceId: "some-workspace-id3",
-        workspaceType: "regular",
-        workspaceClass: "XL",
-        startTime: new Date(Date.now() + -7 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date(Date.now() + -6 * 24 * 3600 * 1000).toISOString(),
-        credits: 300,
-        projectId: "project-134",
-    },
-    {
-        attributionId: "some-attribution-id8",
-        userId: "some-other-user5",
-        teamId: "some-other-team5",
-        instanceId: "some-instance-id8",
-        workspaceId: "some-workspace-id3",
-        workspaceType: "regular",
-        workspaceClass: "standard",
-        startTime: new Date(Date.now() + -1 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date().toISOString(),
-        credits: 100,
-        projectId: "project-567",
-    },
-    {
-        attributionId: "some-attribution-id7",
-        userId: "prebuild",
-        teamId: "some-other-team7",
-        instanceId: "some-instance-id7",
-        workspaceId: "some-workspace-id7",
-        workspaceType: "prebuild",
-        workspaceClass: "XL",
-        startTime: new Date(Date.now() + -1 * 24 * 3600 * 1000).toISOString(),
-        endTime: new Date().toISOString(),
-        credits: 200,
-        projectId: "project-345",
-    },
-];
+export enum CostCenter_BillingStrategy {
+    BILLING_STRATEGY_STRIPE = "BILLING_STRATEGY_STRIPE",
+    BILLING_STRATEGY_OTHER = "BILLING_STRATEGY_OTHER",
+    UNRECOGNIZED = "UNRECOGNIZED",
+}

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

@@ -37,6 +37,11 @@ export class GarbageCollectedCache<T> {
         if (!entry) {
             return undefined;
         }
+        // Still valid?
+        if (entry.expiryDate < Date.now()) {
+            this.store.delete(entry.key);
+            return undefined;
+        }
         return entry.value;
     }
 

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

@@ -85,6 +85,10 @@ export class GitpodHostUrl {
         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: "/" }));
     }
@@ -171,4 +175,21 @@ export class GitpodHostUrl {
     asApiLogout(): GitpodHostUrl {
         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

@@ -4,6 +4,9 @@
  * 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,
@@ -13,3 +16,89 @@ export const defaultGRPCOptions = {
     "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;
+}
+
+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/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();

package/src/util/nice-grpc.ts

@@ -0,0 +1,93 @@
+/**
+ * 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);
+
+        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;
+            }
+            metrics.handled({ ...labels, code: Status[status] });
+        }
+    };
+}

package/src/util/timeutil.spec.ts

@@ -7,10 +7,16 @@
 import * as chai from "chai";
 const expect = chai.expect;
 import { suite, test } from "mocha-typescript";
-import { oneMonthLater } from "./timeutil";
+import { daysBefore, hoursBefore, oneMonthLater } from "./timeutil";
 
 @suite()
 export class TimeutilSpec {
+    @test
+    testDaysBefore() {
+        const now = new Date().toISOString();
+        expect(daysBefore(now, 2)).to.be.eq(hoursBefore(now, 48));
+    }
+
     @test
     testTimeutil() {
         // targeting a 1st, 1th of Jan => 1st of Feb
@@ -39,4 +45,25 @@ export class TimeutilSpec {
         const later = oneMonthLater(from.toISOString(), day);
         expect(later, `expected ${later} to be equal ${expectation}`).to.be.equal(expectation.toISOString());
     }
+
+    @test
+    testDaysBefore2() {
+        const tests: { date: Date; daysEarlier: number; expectation: string }[] = [
+            {
+                date: new Date("2021-07-13T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2020-07-13T00:00:00.000Z",
+            },
+            {
+                date: new Date("2019-02-01T00:00:00.000Z"),
+                daysEarlier: 365,
+                expectation: "2018-02-01T00:00:00.000Z",
+            },
+        ];
+
+        for (const t of tests) {
+            const actual = daysBefore(t.date.toISOString(), t.daysEarlier);
+            expect(actual).to.equal(t.expectation, `expected ${actual} to be equal ${t.expectation}`);
+        }
+    }
 }

package/src/util/timeutil.ts

@@ -47,6 +47,12 @@ export const orderAsc = (d1: string, d2: string): number => liftDate(d1, d2, (d1
 export const liftDate1 = <T>(d1: string, f: (d1: Date) => T): T => f(new Date(d1));
 export const liftDate = <T>(d1: string, d2: string, f: (d1: Date, d2: Date) => T): T => f(new Date(d1), new Date(d2));
 
+export function daysBefore(date: string, days: number): string {
+    const result = new Date(date);
+    result.setDate(result.getDate() - days);
+    return result.toISOString();
+}
+
 export function hoursBefore(date: string, hours: number): string {
     const result = new Date(date);
     result.setHours(result.getHours() - hours);

package/src/workspace-class.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+
+export interface SupportedWorkspaceClass {
+    id: string;
+    category: string;
+    displayName: string;
+    description: string;
+    powerups: number;
+    isSelected: boolean;
+}

package/src/workspace-cluster.ts

@@ -15,6 +15,10 @@ export interface WorkspaceCluster {
     // Must be identical to the installationShortname of the cluster it represents!
     name: string;
 
+    // The name of the application cluster to which this cluster should be registered.
+    // The name can be at most 60 characters.
+    applicationCluster: string;
+
     // URL of the cluster's ws-manager API
     url: string;
 
@@ -86,20 +90,21 @@ export interface WorkspaceClusterDB {
      * Deletes the cluster identified by this name, if any.
      * @param name
      */
-    deleteByName(name: string): Promise<void>;
+    deleteByName(name: string, applicationCluster: string): Promise<void>;
 
     /**
      * Finds a WorkspaceCluster with the given name. If there is none, `undefined` is returned.
      * @param name
      */
-    findByName(name: string): Promise<WorkspaceCluster | undefined>;
+    findByName(name: string, applicationCluster: string): Promise<WorkspaceCluster | undefined>;
 
     /**
      * Lists all WorkspaceClusterWoTls for which the given predicate is true (does not return TLS for size/speed concerns)
      * @param predicate
      */
-    findFiltered(predicate: DeepPartial<WorkspaceClusterFilter>): Promise<WorkspaceClusterWoTLS[]>;
-}
-export interface WorkspaceClusterFilter extends Pick<WorkspaceCluster, "state" | "govern" | "url"> {
-    minScore: number;
+    findFiltered(predicate: WorkspaceClusterFilter): Promise<WorkspaceClusterWoTLS[]>;
 }
+
+export type WorkspaceClusterFilter = Pick<WorkspaceCluster, "applicationCluster"> &
+    DeepPartial<Pick<WorkspaceCluster, "name" | "state" | "govern" | "url">> &
+    Partial<{ minScore: number }>;

package/src/workspace-instance.ts

@@ -246,6 +246,9 @@ export interface WorkspaceInstanceConfiguration {
     // desktopIdeImage is the ref of the desktop IDE image this instance uses.
     desktopIdeImage?: string;
 
+    // desktopIdePluginImage is the ref of the desktop IDE plugin image this instance uses.
+    desktopIdePluginImage?: string;
+
     // supervisorImage is the ref of the supervisor image this instance uses.
     supervisorImage?: string;
 

package/src/wsready.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-// generated using github.com/32leaves/bel on 2022-05-18 18:19:49.011672619 +0000 UTC m=+0.006607361
+// generated using github.com/32leaves/bel on 2022-10-10 21:41:56.018177383 +0000 UTC m=+0.010324839
 // DO NOT MODIFY
 
 export enum WorkspaceInitSource {