@gitpod/gitpod-protocol 0.1.5-sje-kots-node-reqs.1 → 0.1.5-sje-installer-proxy-config-backup.0

package/src/billing-mode.ts

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+/**
+ * BillingMode is used to answer the following questions:
+ *  - Should UI piece x be displayed for this user/team? (getBillingModeForUser/Team)
+ *  - What model should be used to limit this workspace's capabilities (mayStartWorkspace, setTimeout, workspace class, etc...) (getBillingMode(workspaceInstance.attributionId))
+ *  - How is a workspace session charged for? (getBillingMode(workspaceInstance.attributionId))
+ */
+export type BillingMode = None | Chargebee | UsageBased;
+export namespace BillingMode {
+    export const NONE: None = {
+        mode: "none",
+    };
+
+    /** Incl. upgrade and status */
+    export function showUsageBasedBilling(billingMode?: BillingMode): boolean {
+        if (!billingMode) {
+            return false;
+        }
+        return (
+            billingMode.mode === "usage-based" || (billingMode.mode === "chargebee" && !!billingMode.canUpgradeToUBB)
+        );
+    }
+
+    export function canSetWorkspaceClass(billingMode?: BillingMode): boolean {
+        if (!billingMode) {
+            return false;
+        }
+
+        // if has any Stripe subscription, either directly or per team
+        return billingMode.mode === "usage-based";
+    }
+
+    export function canSetCostCenter(billingMode: BillingMode): boolean {
+        // if has any Stripe Subscription, either directly or per team
+        return billingMode.mode === "usage-based";
+    }
+}
+
+/** Payment is disabled */
+interface None {
+    mode: "none";
+}
+
+/** Sessions is handled with old subscription logic based on Chargebee */
+interface Chargebee {
+    mode: "chargebee";
+    canUpgradeToUBB?: boolean;
+}
+
+/** Session is handld with new usage-based logic */
+interface UsageBased {
+    mode: "usage-based";
+
+    /** True iff this is a team, and is based on a paid plan. Currently only set for teams! */
+    paid?: boolean;
+
+    /** User is already converted, but is member with at least one Chargebee-based "Team Plan" */
+    hasChargebeeTeamPlan?: boolean;
+
+    /** User is already converted, but is member in at least one Chargebee-based "Team Subscription" */
+    hasChargebeeTeamSubscription?: boolean;
+}

package/src/experiments/configcat-server.ts

@@ -12,6 +12,9 @@ import { newAlwaysReturningDefaultValueClient } from "./always-default";
 
 let client: Client | undefined;
 
+export type ConfigCatClientFactory = () => Client;
+export const ConfigCatClientFactory = Symbol("ConfigCatClientFactory");
+
 export function getExperimentsClientForBackend(): Client {
     // We have already instantiated a client, we can just re-use it.
     if (client !== undefined) {

package/src/gitpod-service.ts

@@ -60,8 +60,9 @@ import {
 import { RemotePageMessage, RemoteTrackMessage, RemoteIdentifyMessage } from "./analytics";
 import { IDEServer } from "./ide-protocol";
 import { InstallationAdminSettings, TelemetryData } from "./installation-admin-protocol";
-import { Currency } from "./plans";
-import { BillableSession } from "./usage";
+import { ListUsageRequest, ListUsageResponse } from "./usage";
+import { SupportedWorkspaceClass } from "./workspace-class";
+import { BillingMode } from "./billing-mode";
 
 export interface GitpodClient {
     onInstanceUpdate(instance: WorkspaceInstance): void;
@@ -83,6 +84,8 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     getLoggedInUser(): Promise<User>;
     getTerms(): Promise<Terms>;
     updateLoggedInUser(user: Partial<User>): Promise<User>;
+    sendPhoneNumberVerificationToken(phoneNumber: string): Promise<void>;
+    verifyPhoneNumberVerificationToken(phoneNumber: string, token: string): Promise<boolean>;
     getAuthProviders(): Promise<AuthProviderInfo[]>;
     getOwnAuthProviders(): Promise<AuthProviderEntry[]>;
     updateOwnAuthProvider(params: GitpodServer.UpdateOwnAuthProviderParams): Promise<AuthProviderEntry>;
@@ -288,10 +291,19 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     getStripePublishableKey(): Promise<string>;
     getStripeSetupIntentClientSecret(): Promise<string>;
     findStripeSubscriptionIdForTeam(teamId: string): Promise<string | undefined>;
-    subscribeTeamToStripe(teamId: string, setupIntentId: string, currency: Currency): Promise<void>;
+    createOrUpdateStripeCustomerForTeam(teamId: string, currency: string): Promise<void>;
+    createOrUpdateStripeCustomerForUser(currency: string): Promise<void>;
+    subscribeTeamToStripe(teamId: string, setupIntentId: string): Promise<void>;
     getStripePortalUrlForTeam(teamId: string): Promise<string>;
+    getUsageLimitForTeam(teamId: string): Promise<number | undefined>;
+    setUsageLimitForTeam(teamId: string, spendingLimit: number): Promise<void>;
 
-    getBilledUsage(attributionId: string): Promise<BillableSession[]>;
+    listUsage(req: ListUsageRequest): Promise<ListUsageResponse>;
+
+    setUsageAttribution(usageAttribution: string): Promise<void>;
+
+    getBillingModeForUser(): Promise<BillingMode>;
+    getBillingModeForTeam(teamId: string): Promise<BillingMode>;
 
     /**
      * Analytics
@@ -299,6 +311,13 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     trackEvent(event: RemoteTrackMessage): Promise<void>;
     trackLocation(event: RemotePageMessage): Promise<void>;
     identifyUser(event: RemoteIdentifyMessage): Promise<void>;
+
+    /**
+     * Frontend notifications
+     */
+    getNotifications(): Promise<string[]>;
+
+    getSupportedWorkspaceClasses(): Promise<SupportedWorkspaceClass[]>;
 }
 
 export interface RateLimiterError {

package/src/ide-protocol.ts

@@ -116,4 +116,14 @@ export interface IDEOption {
      * we resolve the tag regularly to the most recent image version.
      */
     resolveImageDigest?: boolean;
+
+    /**
+     * The plugin image ref for the IDE image, this image ref always resolve to digest.
+     */
+    pluginImage?: string;
+
+    /**
+     * The latest plugin image ref for the latest IDE image, this image ref always resolve to digest.
+     */
+    pluginLatestImage?: string;
 }

package/src/messaging/client-call-metrics.ts

@@ -6,26 +6,7 @@
 
 import { injectable } from "inversify";
 import * as prometheusClient from "prom-client";
-
-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;
-}
+import { IClientCallMetrics, IGrpcCallMetricsLabels, IGrpcCallMetricsLabelsWithCode } from "../util/grpc";
 
 @injectable()
 export class PrometheusClientCallMetrics implements IClientCallMetrics {

package/src/messaging/error.ts

@@ -26,21 +26,30 @@ export namespace ErrorCodes {
     // 410 No User
     export const SETUP_REQUIRED = 410;
 
+    // 411 No User
+    export const NEEDS_VERIFICATION = 411;
+
     // 429 Too Many Requests
     export const TOO_MANY_REQUESTS = 429;
 
     // 430 Repository not whitelisted (custom status code)
     export const REPOSITORY_NOT_WHITELISTED = 430;
 
+    // 450 Payment error
+    export const PAYMENT_ERROR = 450;
+
+    // 451 Out of credits
+    export const PAYMENT_SPENDING_LIMIT_REACHED = 451;
+
+    // 455 Invalid cost center (custom status code)
+    export const INVALID_COST_CENTER = 455;
+
     // 460 Context Parse Error (custom status code)
     export const CONTEXT_PARSE_ERROR = 460;
 
-    // 461 Invalid gitpod yml
+    // 461 Invalid gitpod yml (custom status code)
     export const INVALID_GITPOD_YML = 461;
 
-    // 450 Payment error
-    export const PAYMENT_ERROR = 450;
-
     // 470 User Blocked (custom status code)
     export const USER_BLOCKED = 470;
 

package/src/plans.ts

@@ -482,6 +482,10 @@ export namespace Plans {
         );
     }
 
+    export function isFreeTier(chargebeeId: string | undefined): boolean {
+        return chargebeeId === Plans.FREE.chargebeeId || chargebeeId === Plans.FREE_50.chargebeeId;
+    }
+
     export function isFreeNonTransientPlan(chargebeeId: string | undefined): boolean {
         return chargebeeId === Plans.FREE_OPEN_SOURCE.chargebeeId;
     }

package/src/protocol.ts

@@ -8,6 +8,7 @@ import { WorkspaceInstance, PortVisibility } from "./workspace-instance";
 import { RoleOrPermission } from "./permission";
 import { Project } from "./teams-projects-protocol";
 import { createHash } from "crypto";
+import { AttributionId } from "./attribution";
 
 export interface UserInfo {
     name?: string;
@@ -45,6 +46,15 @@ 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;
+
+    // The last time this user got verified somehow. The user is not verified if this is empty.
+    lastVerificationTime?: string;
+
+    // The phone number used for the last phone verification.
+    verificationPhoneNumber?: string;
 }
 
 export namespace User {
@@ -199,14 +209,26 @@ 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
     profile?: ProfileDetails;
 }
-
+export namespace AdditionalUserData {
+    export function set(user: User, partialData: Partial<AdditionalUserData>): User {
+        if (!user.additionalData) {
+            user.additionalData = {
+                ...partialData,
+            };
+        } else {
+            user.additionalData = {
+                ...user.additionalData,
+                ...partialData,
+            };
+        }
+        return user;
+    }
+}
 // The format in which we store User Profiles in
 export interface ProfileDetails {
     // when was the last time the user updated their profile information or has been nudged to do so.
@@ -270,9 +292,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 +1503,13 @@ export interface Terms {
     readonly content: string;
     readonly formElements?: object;
 }
+
+export type BillingStrategy = "other" | "stripe";
+export interface CostCenter {
+    readonly id: AttributionId;
+    /**
+     * Unit: credits
+     */
+    spendingLimit: number;
+    billingStrategy: BillingStrategy;
+}

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/usage.ts

@@ -6,141 +6,67 @@
 
 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;
-
-    instanceId: string;
-
-    workspaceId: string;
-
-    workspaceType: BillableWorkspaceType;
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
 
-    // "standard" or "XL"
-    workspaceClass: string;
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
 
-    // When the workspace started
-    startTime: string;
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditBalanceAtStart: number;
+    creditBalanceAtEnd: number;
+}
 
-    // When the workspace ended
-    endTime: string;
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
+}
 
-    // The credits used for this session
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
+    attributionId: string;
+    description: string;
     credits: number;
-
-    // TODO - maybe
-    projectId?: string;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
 }
 
-export type BillableWorkspaceType = WorkspaceType;
+// 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;
+}
 
-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 interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
+}

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();