Revert "[server] Merge WorkspaceDeletionService into WorkspaceGC (#18410)"

This reverts commit 9acc185.

Author: AlexTugarev

components/dashboard/src/service/service-mock.ts

@@ -5,6 +5,7 @@
  */
 
 import { createServiceMock, Event, Project, Team, User } from "@gitpod/gitpod-protocol";
+import { BillingMode } from "@gitpod/gitpod-protocol/lib/billing-mode";
 
 const u1: User = {
     id: "1234",
@@ -253,6 +254,9 @@ const gitpodServiceMock = createServiceMock({
             },
         };
     },
+    getBillingModeForUser: async () => {
+        return BillingMode.NONE;
+    },
 });
 
 export { gitpodServiceMock };

components/gitpod-protocol/src/gitpod-service.ts

@@ -236,6 +236,7 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
 
     listUsage(req: ListUsageRequest): Promise<ListUsageResponse>;
 
+    getBillingModeForUser(): Promise<BillingMode>;
     getBillingModeForTeam(teamId: string): Promise<BillingMode>;
 
     getLinkedInClientId(): Promise<string>;

components/server/src/auth/rate-limiter.ts

@@ -177,6 +177,7 @@ const defaultFunctions: FunctionsConfig = {
     getPriceInformation: { group: "default", points: 1 },
     listUsage: { group: "default", points: 1 },
     getBillingModeForTeam: { group: "default", points: 1 },
+    getBillingModeForUser: { group: "default", points: 1 },
     getLinkedInClientId: { group: "default", points: 1 },
     connectWithLinkedIn: { group: "default", points: 1 },
 

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

@@ -6,6 +6,7 @@
 
 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";
@@ -21,7 +22,7 @@ export class BillingModes {
         @inject(UsageService) private readonly usageService: UsageService,
     ) {}
 
-    public async getBillingMode(userId: string, organizationId: string): Promise<BillingMode> {
+    public async getBillingMode(userId: string, organizationId: string, now: Date): Promise<BillingMode> {
         if (!this.config.enablePayment) {
             // Payment is not enabled. E.g. Dedicated
             return { mode: "none" };
@@ -32,11 +33,7 @@ export class BillingModes {
         return { mode: "usage-based", paid };
     }
 
-    /**
-     * @deprecated use getBillingMode(userId, organizationId) instead
-     * @returns
-     */
-    async getBillingModeForUser(): Promise<BillingMode> {
+    async getBillingModeForUser(user: User, now: Date): 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,10 +38,11 @@ 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.id, organizationId);
+            const max = await this.getMaxParallelWorkspaces(user, date);
             const current = (await runningInstances).filter((i) => i.status.phase !== "preparing").length;
             if (current >= max) {
                 return {
@@ -53,7 +54,7 @@ export class EntitlementServiceUBP implements EntitlementService {
             }
         };
         const [usageLimitReachedOnCostCenter, hitParallelWorkspaceLimit] = await Promise.all([
-            this.checkUsageLimitReached(user.id, organizationId),
+            this.checkUsageLimitReached(user, organizationId, date),
             hasHitParallelWorkspaceLimit(),
         ]);
         return {
@@ -62,63 +63,69 @@ export class EntitlementServiceUBP implements EntitlementService {
         };
     }
 
-    private async checkUsageLimitReached(userId: string, organizationId: string): Promise<AttributionId | undefined> {
-        const result = await this.usageService.checkUsageLimitReached(userId, organizationId);
+    private async checkUsageLimitReached(
+        user: User,
+        organizationId: string,
+        date: Date,
+    ): Promise<AttributionId | undefined> {
+        const result = await this.usageService.checkUsageLimitReached(user.id, organizationId);
         if (result.reached) {
             return result.attributionId;
         }
         return undefined;
     }
 
-    private async getMaxParallelWorkspaces(userId: string, organizationId: string): Promise<number> {
-        if (await this.hasPaidSubscription(userId, organizationId)) {
+    private async getMaxParallelWorkspaces(user: User, date: Date): Promise<number> {
+        if (await this.hasPaidSubscription(user, date)) {
             return MAX_PARALLEL_WORKSPACES_PAID;
         } else {
             return MAX_PARALLEL_WORKSPACES_FREE;
         }
     }
 
-    async maySetTimeout(userId: string, organizationId?: string): Promise<boolean> {
-        return this.hasPaidSubscription(userId, organizationId);
+    async maySetTimeout(user: User, date: Date): Promise<boolean> {
+        return this.hasPaidSubscription(user, date);
     }
 
-    async getDefaultWorkspaceTimeout(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
-        if (await this.hasPaidSubscription(userId, organizationId)) {
+    async getDefaultWorkspaceTimeout(user: User, date: Date): Promise<WorkspaceTimeoutDuration> {
+        if (await this.hasPaidSubscription(user, date)) {
             return WORKSPACE_TIMEOUT_DEFAULT_LONG;
         } else {
             return WORKSPACE_TIMEOUT_DEFAULT_SHORT;
         }
     }
 
-    async getDefaultWorkspaceLifetime(userId: string, organizationId: string): Promise<WorkspaceTimeoutDuration> {
-        if (await this.hasPaidSubscription(userId, organizationId)) {
+    async getDefaultWorkspaceLifetime(user: User, date: Date): Promise<WorkspaceTimeoutDuration> {
+        if (await this.hasPaidSubscription(user, date)) {
             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(userId: string, organizationId: string): Promise<boolean> {
+    async limitNetworkConnections(user: User, date: Date): 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(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
+    private async hasPaidSubscription(user: User, date: Date): Promise<boolean> {
         // Member of paid team?
-        const teams = await this.teamDB.findTeamsByUser(userId);
+        const teams = await this.teamDB.findTeamsByUser(user.id);
         const isTeamSubscribedPromises = teams.map(async (team: Team) => {
-            const { billingStrategy } = await this.usageService.getCostCenter(userId, team.id);
+            const { billingStrategy } = await this.usageService.getCostCenter(user.id, team.id);
             return billingStrategy === CostCenter_BillingStrategy.BILLING_STRATEGY_STRIPE;
         });
         // Return the first truthy promise, or false if all the promises were falsy.
@@ -140,8 +147,8 @@ export class EntitlementServiceUBP implements EntitlementService {
         });
     }
 
-    async getBillingTier(userId: string, organizationId: string): Promise<BillingTier> {
-        const hasPaidPlan = await this.hasPaidSubscription(userId, organizationId);
+    async getBillingTier(user: User): Promise<BillingTier> {
+        const hasPaidPlan = await this.hasPaidSubscription(user, new Date());
         return hasPaidPlan ? "paid" : "free";
     }
 }