[server] Merge WorkspaceDeletionService into WorkspaceGC (#18410)

* [server] Merge WorkspaceDeletionService into WorkspaceGC

* [server] WorkspaceService.getOwnerToken + .getIDECredentials

* review comments

* [server] Cleanup around EntitlementService and BillingMode

Author: geropl

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

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

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

@@ -236,7 +236,6 @@ 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,7 +177,6 @@ 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,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,11 @@ export class BillingModes {
         return { mode: "usage-based", paid };
     }
 
-    async getBillingModeForUser(user: User, now: Date): Promise<BillingMode> {
+    /**
+     * @deprecated use getBillingMode(userId, organizationId) instead
+     * @returns
+     */
+    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";
     }
 }