[server] Cleanup around EntitlementService and BillingMode

Author: geropl

components/server/src/billing/billing-mode.ts

@@ -6,7 +6,6 @@
 
 import { inject, injectable } from "inversify";
 
-import { User } from "@gitpod/gitpod-protocol";
 import { Config } from "../config";
 import { BillingMode } from "@gitpod/gitpod-protocol/lib/billing-mode";
 import { CostCenter_BillingStrategy } from "@gitpod/usage-api/lib/usage/v1/usage.pb";
@@ -22,7 +21,7 @@ export class BillingModes {
         @inject(UsageService) private readonly usageService: UsageService,
     ) {}
 
-    public async getBillingMode(userId: string, organizationId: string, now: Date): Promise<BillingMode> {
+    public async getBillingMode(userId: string, organizationId: string): Promise<BillingMode> {
         if (!this.config.enablePayment) {
             // Payment is not enabled. E.g. Dedicated
             return { mode: "none" };
@@ -33,7 +32,7 @@ export class BillingModes {
         return { mode: "usage-based", paid };
     }
 
-    async getBillingModeForUser(user: User, now: Date): Promise<BillingMode> {
+    async getBillingModeForUser(): Promise<BillingMode> {
         if (!this.config.enablePayment) {
             // Payment is not enabled. E.g. Self-Hosted.
             return { mode: "none" };

components/server/src/billing/entitlement-service-ubp.ts

@@ -6,15 +6,15 @@
 
 import { TeamDB } from "@gitpod/gitpod-db/lib";
 import {
-    BillingTier,
-    Team,
-    User,
     WorkspaceInstance,
     WorkspaceTimeoutDuration,
     WORKSPACE_TIMEOUT_DEFAULT_LONG,
     WORKSPACE_TIMEOUT_DEFAULT_SHORT,
     WORKSPACE_LIFETIME_LONG,
     WORKSPACE_LIFETIME_SHORT,
+    User,
+    BillingTier,
+    Team,
 } from "@gitpod/gitpod-protocol";
 import { AttributionId } from "@gitpod/gitpod-protocol/lib/attribution";
 import { inject, injectable } from "inversify";
@@ -38,11 +38,10 @@ export class EntitlementServiceUBP implements EntitlementService {
     async mayStartWorkspace(
         user: User,
         organizationId: string,
-        date: Date,
         runningInstances: Promise<WorkspaceInstance[]>,
     ): Promise<MayStartWorkspaceResult> {
         const hasHitParallelWorkspaceLimit = async (): Promise<HitParallelWorkspaceLimit | undefined> => {
-            const max = await this.getMaxParallelWorkspaces(user, date);
+            const max = await this.getMaxParallelWorkspaces(user.id, organizationId);
             const current = (await runningInstances).filter((i) => i.status.phase !== "preparing").length;
             if (current >= max) {
                 return {
@@ -54,7 +53,7 @@ export class EntitlementServiceUBP implements EntitlementService {
             }
         };
         const [usageLimitReachedOnCostCenter, hitParallelWorkspaceLimit] = await Promise.all([
-            this.checkUsageLimitReached(user, organizationId, date),
+            this.checkUsageLimitReached(user.id, organizationId),
             hasHitParallelWorkspaceLimit(),
         ]);
         return {
@@ -63,69 +62,63 @@ export class EntitlementServiceUBP implements EntitlementService {
         };
     }
 
-    private async checkUsageLimitReached(
-        user: User,
-        organizationId: string,
-        date: Date,
-    ): Promise<AttributionId | undefined> {
-        const result = await this.usageService.checkUsageLimitReached(user.id, organizationId);
+    private async checkUsageLimitReached(userId: string, organizationId: string): Promise<AttributionId | undefined> {
+        const result = await this.usageService.checkUsageLimitReached(userId, organizationId);
         if (result.reached) {
             return result.attributionId;
         }
         return undefined;
     }
 
-    private async getMaxParallelWorkspaces(user: User, date: Date): Promise<number> {
-        if (await this.hasPaidSubscription(user, date)) {
+    private async getMaxParallelWorkspaces(userId: string, organizationId: string): Promise<number> {
+        if (await this.hasPaidSubscription(userId, organizationId)) {
             return MAX_PARALLEL_WORKSPACES_PAID;
         } else {
             return MAX_PARALLEL_WORKSPACES_FREE;
         }
     }
 
-    async maySetTimeout(user: User, date: Date): Promise<boolean> {
-        return this.hasPaidSubscription(user, date);
+    async maySetTimeout(userId: string, organizationId?: string): Promise<boolean> {
+        return this.hasPaidSubscription(userId, organizationId);
     }
 
-    async getDefaultWorkspaceTimeout(user: User, date: Date): Promise<WorkspaceTimeoutDuration> {
-        if (await this.hasPaidSubscription(user, date)) {
+    async getDefaultWorkspaceTimeout(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
+        if (await this.hasPaidSubscription(userId, organizationId)) {
             return WORKSPACE_TIMEOUT_DEFAULT_LONG;
         } else {
             return WORKSPACE_TIMEOUT_DEFAULT_SHORT;
         }
     }
 
-    async getDefaultWorkspaceLifetime(user: User, date: Date): Promise<WorkspaceTimeoutDuration> {
-        if (await this.hasPaidSubscription(user, date)) {
+    async getDefaultWorkspaceLifetime(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
+        if (await this.hasPaidSubscription(userId, organizationId)) {
             return WORKSPACE_LIFETIME_LONG;
         } else {
             return WORKSPACE_LIFETIME_SHORT;
         }
     }
 
-    /**
-     * DEPRECATED: With usage-based billing, users can choose exactly how many resources they want to get.
-     * Thus, we no longer need to "force" extra resources via the `userGetsMoreResources` mechanism.
-     */
-    async userGetsMoreResources(user: User, date: Date = new Date()): Promise<boolean> {
-        return false;
-    }
-
     /**
      * Returns true if network connections should be limited
      * @param user
      */
-    async limitNetworkConnections(user: User, date: Date): Promise<boolean> {
+    async limitNetworkConnections(userId: string, organizationId: string): Promise<boolean> {
         // gpl: Because with the current payment handling (pay-after-use) having a "paid" plan is not a good enough classifier for trushworthyness atm.
         // We're looking into improving this, but for the meantime we limit network connections for everybody to reduce the impact of abuse.
         return true;
     }
 
-    private async hasPaidSubscription(user: User, date: Date): Promise<boolean> {
+    private async hasPaidSubscription(userId: string, organizationId?: string): Promise<boolean> {
+        if (organizationId) {
+            // This is the "stricter", more correct version: We only allow privileges on the Organization that is paying for it
+            const { billingStrategy } = await this.usageService.getCostCenter(userId, organizationId);
+            return billingStrategy === CostCenter_BillingStrategy.BILLING_STRATEGY_STRIPE;
+        }
+        // This is the old behavior, stemming from our transition to PAYF, where our API did-/doesn't pass organizationId, yet
         // Member of paid team?
-        const teams = await this.teamDB.findTeamsByUser(user.id);
+        const teams = await this.teamDB.findTeamsByUser(userId);
         const isTeamSubscribedPromises = teams.map(async (team: Team) => {
-            const { billingStrategy } = await this.usageService.getCostCenter(user.id, team.id);
+            const { billingStrategy } = await this.usageService.getCostCenter(userId, team.id);
             return billingStrategy === CostCenter_BillingStrategy.BILLING_STRATEGY_STRIPE;
         });
         // Return the first truthy promise, or false if all the promises were falsy.
@@ -147,8 +140,8 @@ export class EntitlementServiceUBP implements EntitlementService {
         });
     }
 
-    async getBillingTier(user: User): Promise<BillingTier> {
-        const hasPaidPlan = await this.hasPaidSubscription(user, new Date());
+    async getBillingTier(userId: string, organizationId: string): Promise<BillingTier> {
+        const hasPaidPlan = await this.hasPaidSubscription(userId, organizationId);
         return hasPaidPlan ? "paid" : "free";
     }
 }

components/server/src/billing/entitlement-service.ts

@@ -47,49 +47,44 @@ export interface EntitlementService {
     mayStartWorkspace(
         user: User,
         organizationId: string,
-        date: Date,
         runningInstances: Promise<WorkspaceInstance[]>,
     ): Promise<MayStartWorkspaceResult>;
 
     /**
      * A user may set the workspace timeout if they have a professional subscription
-     * @param user
-     * @param date The date for which we want to know whether the user is allowed to set a timeout (depends on active subscription)
+     * @param userId
+     * @param organizationId
      */
-    maySetTimeout(user: User, date: Date): Promise<boolean>;
+    maySetTimeout(userId: string, organizationId?: string): Promise<boolean>;
 
     /**
      * Returns the default workspace timeout for the given user at a given point in time
-     * @param user
-     * @param date The date for which we want to know the default workspace timeout (depends on active subscription)
+     * @param userId
+     * @param organizationId
      */
-    getDefaultWorkspaceTimeout(user: User, date: Date): Promise<WorkspaceTimeoutDuration>;
+    getDefaultWorkspaceTimeout(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration>;
 
     /**
      * Returns the default workspace lifetime for the given user at a given point in time
-     * @param user
-     * @param date The date for which we want to know the default workspace timeout (depends on active subscription)
-     */
-    getDefaultWorkspaceLifetime(user: User, date: Date): Promise<WorkspaceTimeoutDuration>;
-
-    /**
-     * Returns true if the user ought to land on a workspace cluster that provides more resources
-     * compared to the default case.
+     * @param userId
+     * @param organizationId
      */
-    userGetsMoreResources(user: User): Promise<boolean>;
+    getDefaultWorkspaceLifetime(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration>;
 
     /**
      * Returns true if network connections should be limited
-     * @param user
+     * @param userId
+     * @param organizationId
      */
-    limitNetworkConnections(user: User, date: Date): Promise<boolean>;
+    limitNetworkConnections(userId: string, organizationId: string): Promise<boolean>;
 
     /**
-     * Returns BillingTier of this particular user
+     * Returns BillingTier of this organization
      *
-     * @param user
+     * @param userId
+     * @param organizationId
      */
-    getBillingTier(user: User): Promise<BillingTier>;
+    getBillingTier(userId: string, organizationId: string): Promise<BillingTier>;
 }
 
 /**
@@ -107,7 +102,6 @@ export class EntitlementServiceImpl implements EntitlementService {
     async mayStartWorkspace(
         user: User,
         organizationId: string,
-        date: Date = new Date(),
         runningInstances: Promise<WorkspaceInstance[]>,
     ): Promise<MayStartWorkspaceResult> {
         try {
@@ -117,13 +111,13 @@ export class EntitlementServiceImpl implements EntitlementService {
                     needsVerification: true,
                 };
             }
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            const billingMode = await this.billingModes.getBillingMode(user.id, organizationId);
             switch (billingMode.mode) {
                 case "none":
                     // if payment is not enabled users can start as many parallel workspaces as they want
                     return {};
                 case "usage-based":
-                    return this.ubp.mayStartWorkspace(user, organizationId, date, runningInstances);
+                    return this.ubp.mayStartWorkspace(user, organizationId, runningInstances);
                 default:
                     throw new Error("Unsupported billing mode: " + (billingMode as any).mode); // safety net
             }
@@ -133,104 +127,87 @@ export class EntitlementServiceImpl implements EntitlementService {
         }
     }
 
-    async maySetTimeout(user: User, date: Date = new Date()): Promise<boolean> {
+    async maySetTimeout(userId: string, organizationId?: string): Promise<boolean> {
         try {
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            const billingMode = await this.billingModes.getBillingModeForUser();
             switch (billingMode.mode) {
                 case "none":
                     // when payment is disabled users can do everything
                     return true;
                 case "usage-based":
-                    return this.ubp.maySetTimeout(user, date);
+                    return this.ubp.maySetTimeout(userId, organizationId);
             }
         } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: maySetTimeout", err);
+            log.error({ userId }, "EntitlementService error: maySetTimeout", err);
             return true;
         }
     }
 
-    async getDefaultWorkspaceTimeout(user: User, date: Date = new Date()): Promise<WorkspaceTimeoutDuration> {
+    async getDefaultWorkspaceTimeout(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
         try {
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            const billingMode = await this.billingModes.getBillingMode(userId, organizationId);
             switch (billingMode.mode) {
                 case "none":
                     return WORKSPACE_TIMEOUT_DEFAULT_LONG;
                 case "usage-based":
-                    return this.ubp.getDefaultWorkspaceTimeout(user, date);
+                    return this.ubp.getDefaultWorkspaceTimeout(userId, organizationId);
             }
         } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: getDefaultWorkspaceTimeout", err);
+            log.error({ userId }, "EntitlementService error: getDefaultWorkspaceTimeout", err);
             return WORKSPACE_TIMEOUT_DEFAULT_LONG;
         }
     }
 
-    async getDefaultWorkspaceLifetime(user: User, date: Date = new Date()): Promise<WorkspaceTimeoutDuration> {
+    async getDefaultWorkspaceLifetime(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
         try {
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            const billingMode = await this.billingModes.getBillingMode(userId, organizationId);
             switch (billingMode.mode) {
                 case "none":
                     return WORKSPACE_LIFETIME_LONG;
                 case "usage-based":
-                    return this.ubp.getDefaultWorkspaceLifetime(user, date);
+                    return this.ubp.getDefaultWorkspaceLifetime(userId, organizationId);
             }
         } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: getDefaultWorkspaceLifetime", err);
+            log.error({ userId }, "EntitlementService error: getDefaultWorkspaceLifetime", err);
             return WORKSPACE_LIFETIME_LONG;
         }
     }
 
-    async userGetsMoreResources(user: User, date: Date = new Date()): Promise<boolean> {
-        try {
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
-            switch (billingMode.mode) {
-                case "none":
-                    // TODO(gpl) Not sure this makes sense, but it's the way it was before
-                    return false;
-                case "usage-based":
-                    return this.ubp.userGetsMoreResources(user);
-            }
-        } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: userGetsMoreResources", err);
-            return true;
-        }
-    }
-
     /**
      * Returns true if network connections should be limited
      * @param user
      */
-    async limitNetworkConnections(user: User, date: Date): Promise<boolean> {
+    async limitNetworkConnections(userId: string, organizationId: string): Promise<boolean> {
         try {
-            const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            const billingMode = await this.billingModes.getBillingMode(userId, organizationId);
             switch (billingMode.mode) {
                 case "none":
                     return false;
                 case "usage-based":
-                    return this.ubp.limitNetworkConnections(user, date);
+                    return this.ubp.limitNetworkConnections(userId, organizationId);
             }
         } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: limitNetworkConnections", err);
+            log.error({ userId }, "EntitlementService error: limitNetworkConnections", err);
             return false;
         }
     }
 
     /**
      * Returns true if network connections should be limited
-     * @param user
+     * @param userId
+     * @param organizationId
      */
-    async getBillingTier(user: User): Promise<BillingTier> {
+    async getBillingTier(userId: string, organizationId: string): Promise<BillingTier> {
         try {
-            const now = new Date();
-            const billingMode = await this.billingModes.getBillingModeForUser(user, now);
+            const billingMode = await this.billingModes.getBillingMode(userId, organizationId);
             switch (billingMode.mode) {
                 case "none":
-                    // TODO(gpl) Is this true? Cross-check this whole interface with Self-Hosted before next release!
                     return "paid";
                 case "usage-based":
-                    return this.ubp.getBillingTier(user);
+                    return billingMode.paid ? "paid" : "free";
             }
         } catch (err) {
-            log.error({ userId: user.id }, "EntitlementService error: getBillingTier", err);
+            log.error({ userId }, "EntitlementService error: getBillingTier", err);
             return "paid";
         }
     }

components/server/src/prebuilds/prebuild-manager.ts

@@ -293,12 +293,7 @@ export class PrebuildManager {
     protected async checkUsageLimitReached(user: User, organizationId: string): Promise<void> {
         let result: MayStartWorkspaceResult = {};
         try {
-            result = await this.entitlementService.mayStartWorkspace(
-                user,
-                organizationId,
-                new Date(),
-                Promise.resolve([]),
-            );
+            result = await this.entitlementService.mayStartWorkspace(user, organizationId, Promise.resolve([]));
         } catch (err) {
             log.error({ userId: user.id }, "EntitlementService.mayStartWorkspace error", err);
             return; // we don't want to block workspace starts because of internal errors