KB 9.0 compatibility (#2061)

* sync serve

* sycn web

* chore

Author: HUAHUAI23

server/src/application/application.controller.ts

@@ -56,6 +56,11 @@ import { GroupWithRole } from 'src/group/entities/group'
 import { isEqual } from 'lodash'
 import { InstanceService } from 'src/instance/instance.service'
 import { QuotaService } from 'src/user/quota.service'
+import { DedicatedDatabaseService } from 'src/database/dedicated-database/dedicated-database.service'
+import {
+  DedicatedDatabasePhase,
+  DedicatedDatabaseState,
+} from 'src/database/entities/dedicated-database'
 
 @ApiTags('Application')
 @Controller('applications')
@@ -73,6 +78,7 @@ export class ApplicationController {
     private readonly resource: ResourceService,
     private readonly runtimeDomain: RuntimeDomainService,
     private readonly quotaServiceTsService: QuotaService,
+    private readonly dedicateDatabase: DedicatedDatabaseService,
   ) {}
 
   /**
@@ -253,6 +259,7 @@ export class ApplicationController {
     if (dto.state === ApplicationState.Deleted) {
       throw new ForbiddenException('cannot update state to deleted')
     }
+    const ddb = await this.dedicateDatabase.findOne(appid)
     const userid = app.createdBy
 
     // check account balance
@@ -265,8 +272,10 @@ export class ApplicationController {
     // check: only running application can restart
     if (
       dto.state === ApplicationState.Restarting &&
-      app.state !== ApplicationState.Running &&
-      app.phase !== ApplicationPhase.Started
+      !(
+        app.state === ApplicationState.Running &&
+        app.phase === ApplicationPhase.Started
+      )
     ) {
       return ResponseUtil.error(
         'The application is not running, can not restart it',
@@ -276,8 +285,8 @@ export class ApplicationController {
     // check: only running application can stop
     if (
       dto.state === ApplicationState.Stopped &&
-      app.state !== ApplicationState.Running &&
-      app.phase !== ApplicationPhase.Started
+      (app.state !== ApplicationState.Running ||
+        app.phase !== ApplicationPhase.Started)
     ) {
       return ResponseUtil.error(
         'The application is not running, can not stop it',
@@ -287,8 +296,8 @@ export class ApplicationController {
     // check: only stopped application can start
     if (
       dto.state === ApplicationState.Running &&
-      app.state !== ApplicationState.Stopped &&
-      app.phase !== ApplicationPhase.Stopped
+      (app.state !== ApplicationState.Stopped ||
+        app.phase !== ApplicationPhase.Stopped)
     ) {
       return ResponseUtil.error(
         'The application is not stopped, can not start it',
@@ -304,6 +313,20 @@ export class ApplicationController {
       return ResponseUtil.error('no permission')
     }
 
+    if (ddb) {
+      if (dto.state === ApplicationState.Restarting && dto?.onlyRuntimeFlag) {
+        const doc = await this.application.updateState(appid, dto.state)
+        return ResponseUtil.ok(doc)
+      }
+
+      const doc = await this.application.updateState(appid, dto.state)
+      await this.dedicateDatabase.updateState(
+        appid,
+        dto.state as unknown as DedicatedDatabaseState,
+      )
+      return ResponseUtil.ok(doc)
+    }
+
     const doc = await this.application.updateState(appid, dto.state)
     return ResponseUtil.ok(doc)
   }
@@ -322,6 +345,13 @@ export class ApplicationController {
     @InjectApplication() app: ApplicationWithRelations,
     @InjectUser() user: User,
   ) {
+    // only running application can update bundle
+    if (app.phase !== ApplicationPhase.Started) {
+      return ResponseUtil.error(
+        'The application is not running, can not update bundle',
+      )
+    }
+
     const error = dto.autoscaling.validate()
     if (error) {
       return ResponseUtil.error(error)
@@ -354,11 +384,44 @@ export class ApplicationController {
       return ResponseUtil.error('cannot change database type')
     }
 
-    const checkSpec = await this.checkResourceSpecification(dto, regionId)
+    const checkSpec = await this.checkResourceSpecification(dto, regionId, app)
     if (!checkSpec) {
       return ResponseUtil.error('invalid resource specification')
     }
 
+    // Check if user is trying to change dedicated database resources
+    const isTryingToChangeDedicatedDatabase =
+      (dto.dedicatedDatabase?.cpu !== undefined &&
+        dto.dedicatedDatabase?.cpu !==
+          origin.resource.dedicatedDatabase?.limitCPU) ||
+      (dto.dedicatedDatabase?.memory !== undefined &&
+        dto.dedicatedDatabase?.memory !==
+          origin.resource.dedicatedDatabase?.limitMemory) ||
+      (dto.dedicatedDatabase?.replicas !== undefined &&
+        dto.dedicatedDatabase?.replicas !==
+          origin.resource.dedicatedDatabase?.replicas) ||
+      (dto.dedicatedDatabase?.capacity !== undefined &&
+        dto.dedicatedDatabase?.capacity !==
+          origin.resource.dedicatedDatabase?.capacity)
+
+    if (isTryingToChangeDedicatedDatabase) {
+      const ddb = await this.dedicateDatabase.findOne(appid)
+      // Database must be running to change database resources
+      if (!ddb) {
+        return ResponseUtil.error(
+          'DedicatedDatabase not found, cannot change DedicatedDatabase database resources',
+        )
+      }
+      if (
+        ddb.state !== DedicatedDatabaseState.Running ||
+        ddb.phase !== DedicatedDatabasePhase.Started
+      ) {
+        return ResponseUtil.error(
+          'DedicatedDatabase is not in running state, cannot change DedicatedDatabase database resources',
+        )
+      }
+    }
+
     if (
       dto.dedicatedDatabase?.capacity &&
       origin.resource.dedicatedDatabase?.capacity &&
@@ -393,12 +456,15 @@ export class ApplicationController {
     const doc = await this.application.updateBundle(appid, dto, isTrialTier)
 
     // restart running application if cpu or memory changed
-    const isRunning = app.phase === ApplicationPhase.Started
     const isCpuChanged = origin.resource.limitCPU !== doc.resource.limitCPU
     const isMemoryChanged =
       origin.resource.limitMemory !== doc.resource.limitMemory
     const isAutoscalingCanceled =
       !doc.autoscaling.enable && origin.autoscaling.enable
+
+    const isRuntimeChanged =
+      isCpuChanged || isMemoryChanged || isAutoscalingCanceled
+
     const isDedicatedDatabaseChanged =
       !!origin.resource.dedicatedDatabase &&
       (!isEqual(
@@ -423,13 +489,16 @@ export class ApplicationController {
       await this.instance.reapplyHorizontalPodAutoscaler(app, hpa)
     }
 
-    if (
-      isRunning &&
-      (isCpuChanged ||
-        isMemoryChanged ||
-        isAutoscalingCanceled ||
-        isDedicatedDatabaseChanged)
-    ) {
+    if (isDedicatedDatabaseChanged) {
+      await this.application.updateState(appid, ApplicationState.Restarting)
+      await this.dedicateDatabase.updateState(
+        appid,
+        DedicatedDatabaseState.Restarting,
+      )
+      return ResponseUtil.ok(doc)
+    }
+
+    if (isRuntimeChanged) {
       await this.application.updateState(appid, ApplicationState.Restarting)
     }
 
@@ -540,8 +609,80 @@ export class ApplicationController {
   private async checkResourceSpecification(
     dto: UpdateApplicationBundleDto,
     regionId: ObjectId,
+    app?: ApplicationWithRelations,
   ) {
     const resourceOptions = await this.resource.findAllByRegionId(regionId)
+
+    if (app) {
+      const checkSpec = resourceOptions.every((option) => {
+        switch (option.type) {
+          case 'cpu':
+            return (
+              option.specs.some((spec) => spec.value === dto.cpu) ||
+              app.bundle.resource.limitCPU === dto.cpu
+            )
+          case 'memory':
+            return (
+              option.specs.some((spec) => spec.value === dto.memory) ||
+              app.bundle.resource.limitMemory === dto.memory
+            )
+          case 'databaseCapacity':
+            if (!dto.databaseCapacity) return true
+            return (
+              option.specs.some(
+                (spec) => spec.value === dto.databaseCapacity,
+              ) || app.bundle.resource.databaseCapacity === dto.databaseCapacity
+            )
+          case 'storageCapacity':
+            if (!dto.storageCapacity) return true
+            return (
+              option.specs.some((spec) => spec.value === dto.storageCapacity) ||
+              app.bundle.resource.storageCapacity === dto.storageCapacity
+            )
+          // dedicated database
+          case 'dedicatedDatabaseCPU':
+            return (
+              !dto.dedicatedDatabase?.cpu ||
+              option.specs.some(
+                (spec) => spec.value === dto.dedicatedDatabase.cpu,
+              ) ||
+              app.bundle.resource.dedicatedDatabase?.limitCPU ===
+                dto.dedicatedDatabase.cpu
+            )
+          case 'dedicatedDatabaseMemory':
+            return (
+              !dto.dedicatedDatabase?.memory ||
+              option.specs.some(
+                (spec) => spec.value === dto.dedicatedDatabase.memory,
+              ) ||
+              app.bundle.resource.dedicatedDatabase?.limitMemory ===
+                dto.dedicatedDatabase.memory
+            )
+          case 'dedicatedDatabaseCapacity':
+            return (
+              !dto.dedicatedDatabase?.capacity ||
+              option.specs.some(
+                (spec) => spec.value === dto.dedicatedDatabase.capacity,
+              ) ||
+              app.bundle.resource.dedicatedDatabase?.capacity ===
+                dto.dedicatedDatabase.capacity
+            )
+          case 'dedicatedDatabaseReplicas':
+            return (
+              !dto.dedicatedDatabase?.replicas ||
+              option.specs.some(
+                (spec) => spec.value === dto.dedicatedDatabase.replicas,
+              ) ||
+              app.bundle.resource.dedicatedDatabase?.replicas ===
+                dto.dedicatedDatabase.replicas
+            )
+          default:
+            return true
+        }
+      })
+      return checkSpec
+    }
+
     const checkSpec = resourceOptions.every((option) => {
       switch (option.type) {
         case 'cpu':

server/src/application/dto/update-application.dto.ts

@@ -8,6 +8,7 @@ import {
   IsString,
   Length,
   ValidateNested,
+  IsBoolean,
 } from 'class-validator'
 import { ApplicationState } from '../entities/application'
 import { CreateAutoscalingDto } from './create-autoscaling.dto'
@@ -52,6 +53,15 @@ export class UpdateApplicationStateDto {
   @IsIn(STATES)
   @IsNotEmpty()
   state: ApplicationState
+
+  @ApiProperty({
+    required: false,
+    description: 'Flag for runtime only operations',
+    type: Boolean,
+  })
+  @IsOptional()
+  @IsBoolean()
+  onlyRuntimeFlag?: boolean
 }
 
 export class UpdateApplicationBundleDto {

server/src/billing/billing-payment-task.service.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger } from '@nestjs/common'
 import { Cron, CronExpression } from '@nestjs/schedule'
 import {
   Application,
+  ApplicationPhase,
   ApplicationState,
 } from 'src/application/entities/application'
 import { ServerConfig, TASK_LOCK_INIT_TIME } from 'src/constants'
@@ -16,6 +17,11 @@ import { AccountTransaction } from 'src/account/entities/account-transaction'
 import Decimal from 'decimal.js'
 import { NotificationService } from 'src/notification/notification.service'
 import { NotificationType } from 'src/notification/notification-type'
+import {
+  DedicatedDatabase,
+  DedicatedDatabasePhase,
+  DedicatedDatabaseState,
+} from 'src/database/entities/dedicated-database'
 
 @Injectable()
 export class BillingPaymentTaskService {
@@ -150,13 +156,40 @@ export class BillingPaymentTaskService {
             { appid: billing.appid, state: ApplicationState.Running },
             {
               $set: {
+                phase: ApplicationPhase.Stopping,
                 state: ApplicationState.Stopped,
                 forceStoppedAt: new Date(),
               },
             },
             { session },
           )
 
+          const ddb = await db
+            .collection<DedicatedDatabase>('DedicatedDatabase')
+            .findOne(
+              {
+                appid: billing.appid,
+              },
+              { session },
+            )
+
+          if (ddb) {
+            await db
+              .collection<DedicatedDatabase>('DedicatedDatabase')
+              .updateOne(
+                {
+                  appid: billing.appid,
+                },
+                {
+                  $set: {
+                    phase: DedicatedDatabasePhase.Stopping,
+                    state: DedicatedDatabaseState.Stopped,
+                  },
+                },
+                { session },
+              )
+          }
+
           if (res.modifiedCount > 0) {
             this.logger.warn(
               `Application ${billing.appid} stopped due to insufficient balance`,