@gitpod/gitpod-protocol 0.1.5-pavel-git-status-fix.5 → 0.1.5-pavel-fixlog.0

package/src/protocol.ts

@@ -45,6 +45,9 @@ export interface User {
     markedDeleted?: boolean;
 
     additionalData?: AdditionalUserData;
+
+    // Identifies an explicit team or user ID to which all the user's workspace usage should be attributed to (e.g. for billing purposes)
+    usageAttributionId?: string;
 }
 
 export namespace User {
@@ -199,8 +202,6 @@ export interface AdditionalUserData {
     knownGitHubOrgs?: string[];
     // Git clone URL pointing to the user's dotfile repo
     dotfileRepo?: string;
-    // Identifies an explicit team or user ID to which all the user's workspace usage should be attributed to (e.g. for billing purposes)
-    usageAttributionId?: string;
     // preferred workspace classes
     workspaceClasses?: WorkspaceClasses;
     // additional user profile data
@@ -270,9 +271,9 @@ export interface UserFeatureSettings {
  */
 export const WorkspaceFeatureFlags = {
     full_workspace_backup: undefined,
-    fixed_resources: undefined,
     persistent_volume_claim: undefined,
     protected_secrets: undefined,
+    workspace_class_limiting: undefined,
 };
 export type NamedWorkspaceFeatureFlag = keyof typeof WorkspaceFeatureFlags;
 
@@ -1481,3 +1482,11 @@ export interface Terms {
     readonly content: string;
     readonly formElements?: object;
 }
+
+export interface CostCenter {
+    readonly id: string;
+    /**
+     * Unit: credits
+     */
+    spendingLimit: number;
+}

package/src/team-subscription-protocol.ts

@@ -55,6 +55,9 @@ export namespace TeamSubscription2 {
     export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
         return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
     };
+    export function isCancelled(s: TeamSubscription2, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
+    }
 }
 
 /**

package/src/teams-projects-protocol.ts

@@ -7,6 +7,7 @@
 import { PrebuiltWorkspaceState } 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;
@@ -152,3 +153,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

@@ -20,14 +20,13 @@ export interface BillableSession {
 
     workspaceType: BillableWorkspaceType;
 
-    // "standard" or "XL"
     workspaceClass: string;
 
     // When the workspace started
     startTime: string;
 
-    // When the workspace ended
-    endTime: string;
+    // When the workspace ended. Not set when the workspace is still running.
+    endTime?: string;
 
     // The credits used for this session
     credits: number;
@@ -36,111 +35,16 @@ export interface BillableSession {
     projectId?: string;
 }
 
+export interface BillableSessionRequest {
+    attributionId: string;
+    startedTimeOrder: SortOrder;
+    from?: number;
+    to?: number;
+}
+
 export type BillableWorkspaceType = WorkspaceType;
 
-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 SortOrder {
+    Descending = 0,
+    Ascending = 1,
+}

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/webhook-event.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 WebhookEvent {
+    id: string;
+    creationTime: string;
+    type: "push" | string;
+
+    /**
+     * Typically the webhook installer is referenced here.
+     */
+    authorizedUserId?: string;
+
+    /**
+     * webhook event's payload
+     */
+    rawEvent: string;
+
+    /**
+     * The general status of the received webhook event.
+     */
+    status: WebhookEvent.Status;
+
+    /**
+     * Optional message to help understand errors with handling events.
+     */
+    message?: string;
+
+    /**
+     * If the webhook event is considered to trigger a prebuild, the `prebuildStatus`
+     * contains a more specific status.
+     */
+    prebuildStatus?: WebhookEvent.PrebuildStatus;
+
+    /**
+     * If `prebuildStatus` is `prebuild_triggered` this points to a prebuild.
+     */
+    prebuildId?: string;
+
+    projectId?: string;
+
+    cloneUrl?: string;
+
+    branch?: string;
+
+    commit?: string;
+}
+
+export namespace WebhookEvent {
+    export type Status = "received" | "dismissed_unauthorized" | "ignored" | "processed";
+    export type PrebuildStatus = "ignored_unconfigured" | "prebuild_trigger_failed" | "prebuild_triggered";
+}

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;
+    isDefault: boolean;
+}

package/src/workspace-cluster.ts

@@ -56,13 +56,9 @@ export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "ur
 export type AdmissionConstraint =
     | AdmissionConstraintFeaturePreview
     | AdmissionConstraintHasPermission
-    | AdmissionConstraintHasUserLevel
-    | AdmissionConstraintHasMoreResources
     | AdmissionConstraintHasClass;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
 export type AdmissionConstraintHasPermission = { type: "has-permission"; permission: PermissionName };
-export type AdmissionConstraintHasUserLevel = { type: "has-user-level"; level: string };
-export type AdmissionConstraintHasMoreResources = { type: "has-more-resources" };
 export type AdmissionConstraintHasClass = { type: "has-class"; id: string; displayName: string };
 
 export namespace AdmissionConstraint {

package/src/wsready.ts

@@ -4,14 +4,15 @@
  * 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-07-21 07:41:48.081573085 +0000 UTC m=+0.009109470
 // DO NOT MODIFY
 
+export interface WorkspaceReadyMessage {
+    source: WorkspaceInitSource;
+}
+
 export enum WorkspaceInitSource {
     WorkspaceInitFromBackup = "from-backup",
     WorkspaceInitFromPrebuild = "from-prebuild",
     WorkspaceInitFromOther = "from-other",
 }
-export interface WorkspaceReadyMessage {
-    source: WorkspaceInitSource;
-}