Fix issues with entitlement service

Author: AlexTugarev

components/dashboard/src/start/CreateWorkspace.tsx

@@ -372,8 +372,7 @@ function SpendingLimitReachedModal(p: { hints: any }) {
     const [attributedTeam, setAttributedTeam] = useState<Team | undefined>();
 
     useEffect(() => {
-        const attributionId: AttributionId | undefined =
-            p.hints && p.hints.attributionId && AttributionId.parse(p.hints.attributionId);
+        const attributionId: AttributionId | undefined = p.hints && p.hints.attributionId;
         if (attributionId) {
             // setAttributionId(attributionId);
             if (attributionId.kind === "team") {

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

@@ -9,7 +9,7 @@ import { User } from "@gitpod/gitpod-protocol";
 import { AttributionId } from "@gitpod/gitpod-protocol/lib/attribution";
 import { BillableSession, BillableSessionRequest, SortOrder } from "@gitpod/gitpod-protocol/lib/usage";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
-import { UsageService, UsageServiceClientProvider } from "@gitpod/usage-api/lib/usage/v1/sugar";
+import { CachingUsageServiceClientProvider, UsageService } from "@gitpod/usage-api/lib/usage/v1/sugar";
 import { Timestamp } from "google-protobuf/google/protobuf/timestamp_pb";
 import { inject, injectable } from "inversify";
 import { UserService } from "../../../src/user/user-service";
@@ -24,7 +24,8 @@ export interface SpendingLimitReachedResult {
 export class BillingService {
     @inject(UserService) protected readonly userService: UserService;
     @inject(CostCenterDB) protected readonly costCenterDB: CostCenterDB;
-    @inject(UsageServiceClientProvider) protected readonly usageServiceClientProvider: UsageServiceClientProvider;
+    @inject(CachingUsageServiceClientProvider)
+    protected readonly usageServiceClientProvider: CachingUsageServiceClientProvider;
 
     async checkSpendingLimitReached(user: User): Promise<SpendingLimitReachedResult> {
         const attributionId = await this.userService.getWorkspaceUsageAttributionId(user);

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

@@ -57,8 +57,13 @@ export class EntitlementServiceChargebee implements EntitlementService {
             hasHitParallelWorkspaceLimit(),
         ]);
 
+        const result = enoughCredits && !hitParallelWorkspaceLimit;
+
+        console.log("mayStartWorkspace > hitParallelWorkspaceLimit " + hitParallelWorkspaceLimit);
+
         return {
-            enoughCredits: !!enoughCredits,
+            mayStart: result,
+            oufOfCredits: !enoughCredits,
             hitParallelWorkspaceLimit,
         };
     }
@@ -82,6 +87,7 @@ export class EntitlementServiceChargebee implements EntitlementService {
         const cachedAccountStatement = this.accountStatementProvider.getCachedStatement();
         const lowerBound = this.getRemainingUsageHoursLowerBound(cachedAccountStatement, date.toISOString());
         if (lowerBound && (lowerBound === "unlimited" || lowerBound > Accounting.MINIMUM_CREDIT_FOR_OPEN_IN_HOURS)) {
+            console.log("checkEnoughCreditForWorkspaceStart > unlimited");
             return true;
         }
 
@@ -90,6 +96,7 @@ export class EntitlementServiceChargebee implements EntitlementService {
             date.toISOString(),
             runningInstances,
         );
+        console.log("checkEnoughCreditForWorkspaceStart > remainingUsageHours " + remainingUsageHours);
         return remainingUsageHours > Accounting.MINIMUM_CREDIT_FOR_OPEN_IN_HOURS;
     }
 

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

@@ -30,7 +30,7 @@ export class EntitlementServiceLicense implements EntitlementService {
         runningInstances: Promise<WorkspaceInstance[]>,
     ): Promise<MayStartWorkspaceResult> {
         // if payment is not enabled users can start as many parallel workspaces as they want
-        return { enoughCredits: true };
+        return { mayStart: true };
     }
 
     async maySetTimeout(user: User, date: Date): Promise<boolean> {

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

@@ -57,8 +57,9 @@ export class EntitlementServiceUBP implements EntitlementService {
             this.checkSpendingLimitReached(user, date),
             hasHitParallelWorkspaceLimit(),
         ]);
-
+        const result = !spendingLimitReachedOnCostCenter && !hitParallelWorkspaceLimit;
         return {
+            mayStart: result,
             spendingLimitReachedOnCostCenter,
             hitParallelWorkspaceLimit,
         };

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

@@ -39,17 +39,24 @@ export class EntitlementServiceImpl implements EntitlementService {
     ): Promise<MayStartWorkspaceResult> {
         try {
             const billingMode = await this.billingModes.getBillingModeForUser(user, date);
+            let result;
             switch (billingMode.mode) {
                 case "none":
-                    return this.license.mayStartWorkspace(user, date, runningInstances);
+                    result = await this.license.mayStartWorkspace(user, date, runningInstances);
+                    break;
                 case "chargebee":
-                    return this.chargebee.mayStartWorkspace(user, date, runningInstances);
+                    result = await this.chargebee.mayStartWorkspace(user, date, runningInstances);
+                    break;
                 case "usage-based":
-                    return this.ubp.mayStartWorkspace(user, date, runningInstances);
+                    result = await this.ubp.mayStartWorkspace(user, date, runningInstances);
+                    break;
+                default:
+                    throw new Error("Unsupported billing mode: " + (billingMode as any).mode); // safety net
             }
+            return result;
         } catch (err) {
             log.error({ userId: user.id }, "EntitlementService error: mayStartWorkspace", err);
-            return {};
+            throw err;
         }
     }
 

components/server/ee/src/user/user-service.ts

@@ -20,11 +20,9 @@ import { SubscriptionService } from "@gitpod/gitpod-payment-endpoint/lib/account
 import { OssAllowListDB } from "@gitpod/gitpod-db/lib/oss-allowlist-db";
 import { HostContextProvider } from "../../../src/auth/host-context-provider";
 import { Config } from "../../../src/config";
-import { EntitlementService } from "../../../src/billing/entitlement-service";
 
 export class UserServiceEE extends UserService {
     @inject(LicenseEvaluator) protected readonly licenseEvaluator: LicenseEvaluator;
-    @inject(EntitlementService) protected readonly entitlementService: EntitlementService;
     @inject(SubscriptionService) protected readonly subscriptionService: SubscriptionService;
     @inject(OssAllowListDB) protected readonly OssAllowListDb: OssAllowListDB;
     @inject(HostContextProvider) protected readonly hostContextProvider: HostContextProvider;

components/server/ee/src/workspace/gitpod-server-impl.ts

@@ -256,14 +256,23 @@ export class GitpodServerEEImpl extends GitpodServerImpl {
     ): Promise<void> {
         await super.mayStartWorkspace(ctx, user, runningInstances);
 
-        const result = await this.entitlementService.mayStartWorkspace(user, new Date(), runningInstances);
-        if (!result.enoughCredits) {
+        let result;
+        try {
+            result = await this.entitlementService.mayStartWorkspace(user, new Date(), runningInstances);
+        } catch (error) {
+            throw new ResponseError(ErrorCodes.INTERNAL_SERVER_ERROR, `Error in Entitlement Service.`);
+        }
+        log.info("mayStartWorkspace", { result });
+        if (result.mayStart) {
+            return; // green light from entitlement service
+        }
+        if (!!result.oufOfCredits) {
             throw new ResponseError(
                 ErrorCodes.NOT_ENOUGH_CREDIT,
                 `Not enough monthly workspace hours. Please upgrade your account to get more hours for your workspaces.`,
             );
         }
-        if (result.spendingLimitReachedOnCostCenter) {
+        if (!!result.spendingLimitReachedOnCostCenter) {
             throw new ResponseError(
                 ErrorCodes.PAYMENT_SPENDING_LIMIT_REACHED,
                 "Increase spending limit and try again.",

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

@@ -14,8 +14,11 @@ import { AttributionId } from "@gitpod/gitpod-protocol/lib/attribution";
 import { injectable } from "inversify";
 
 export interface MayStartWorkspaceResult {
+    mayStart: boolean;
+
     hitParallelWorkspaceLimit?: HitParallelWorkspaceLimit;
-    enoughCredits?: boolean;
+
+    oufOfCredits?: boolean;
 
     /** Usage-Based Pricing: AttributionId of the CostCenter that reached it's spending limit */
     spendingLimitReachedOnCostCenter?: AttributionId;
@@ -72,7 +75,7 @@ export class CommunityEntitlementService implements EntitlementService {
         date: Date,
         runningInstances: Promise<WorkspaceInstance[]>,
     ): Promise<MayStartWorkspaceResult> {
-        return { enoughCredits: true };
+        return { mayStart: true };
     }
 
     async maySetTimeout(user: User, date: Date): Promise<boolean> {

components/server/src/workspace/gitpod-server-impl.ts

@@ -1047,7 +1047,7 @@ export class GitpodServerImpl implements GitpodServerWithTracing, Disposable {
             // make sure we've checked that the user has enough credit before consuming any resources.
             // Be sure to check this before prebuilds and create workspace, too!
             let context = await contextPromise;
-            await Promise.all([this.mayStartWorkspace(ctx, user, runningInstancesPromise)]);
+            await this.mayStartWorkspace(ctx, user, runningInstancesPromise);
 
             if (SnapshotContext.is(context)) {
                 // TODO(janx): Remove snapshot access tracking once we're certain that enforcing repository read access doesn't disrupt the snapshot UX.