feat(server): implement website hosting task (#774)

maslow · web-flow · commit e1e597dc20de · 2023-02-13T11:40:54.000+08:00
diff --git a/server/prisma/schema.prisma b/server/prisma/schema.prisma
@@ -275,7 +275,7 @@ model Database {
   user     String
   password String
   state     DatabaseState @default(Active)
-  phase     DatabasePhase @default(Created)
+  phase     DatabasePhase @default(Creating)
   lockedAt  DateTime
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
diff --git a/server/src/application/application-task.service.ts b/server/src/application/application-task.service.ts
@@ -1,6 +1,13 @@
 import { Injectable, Logger } from '@nestjs/common'
 import { Cron, CronExpression } from '@nestjs/schedule'
-import { Application, ApplicationPhase, ApplicationState } from '@prisma/client'
+import {
+  Application,
+  ApplicationPhase,
+  ApplicationState,
+  DatabasePhase,
+  DomainPhase,
+  StoragePhase,
+} from '@prisma/client'
 import * as assert from 'node:assert'
 import { StorageService } from '../storage/storage.service'
 import { DatabaseService } from '../database/database.service'
@@ -89,10 +96,7 @@ export class ApplicationTaskService {
     let storage = await this.storageService.findOne(appid)
     if (!storage) {
       this.logger.log(`Creating storage for application ${appid}`)
-      const res = await this.storageService.create(app.appid)
-      if (res) {
-        storage = res
-      }
+      storage = await this.storageService.create(app.appid)
     }
 
     // reconcile database
@@ -109,9 +113,18 @@ export class ApplicationTaskService {
       gateway = await this.gatewayService.create(appid)
     }
 
-    if (!gateway) return await this.unlock(appid)
-    if (!storage) return await this.unlock(appid)
-    if (!database) return await this.unlock(appid)
+    // waiting resources' phase to be `Created`
+    if (gateway?.phase !== DomainPhase.Created) {
+      return await this.unlock(appid)
+    }
+
+    if (storage?.phase !== StoragePhase.Created) {
+      return await this.unlock(appid)
+    }
+
+    if (database?.phase !== DatabasePhase.Created) {
+      return await this.unlock(appid)
+    }
 
     // update application phase to `Created`
     const updated = await db.collection<Application>('Application').updateOne(
@@ -257,7 +270,7 @@ export class ApplicationTaskService {
         },
       },
     )
-    if (updated.modifiedCount > 0) this.logger.debug('unlocked app: ' + appid)
+    if (updated.modifiedCount > 0) this.logger.debug(`unlocked app: ${appid}`)
   }
 
   /**
diff --git a/server/src/gateway/apisix.service.ts b/server/src/gateway/apisix.service.ts
@@ -1,6 +1,6 @@
 import { HttpService } from '@nestjs/axios'
 import { Injectable, Logger } from '@nestjs/common'
-import { Region } from '@prisma/client'
+import { Region, WebsiteHosting } from '@prisma/client'
 import { GetApplicationNamespaceById } from '../utils/getter'
 
 @Injectable()
@@ -17,6 +17,10 @@ export class ApisixService {
     const id = `app-${appid}`
     const data = {
       name: id,
+      labels: {
+        type: 'runtime',
+        appid: appid,
+      },
       uri: '/*',
       hosts: [host],
       priority: 9,
@@ -56,6 +60,10 @@ export class ApisixService {
     const id = `bucket-${bucketName}`
     const data = {
       name: id,
+      labels: {
+        type: 'bucket',
+        bucket: bucketName,
+      },
       uri: '/*',
       hosts: [host],
       priority: 9,
@@ -85,18 +93,73 @@ export class ApisixService {
     return res
   }
 
+  async createWebsiteRoute(
+    region: Region,
+    website: WebsiteHosting,
+    bucketDomain: string,
+  ) {
+    const host = website.domain
+    const minioUrl = new URL(region.storageConf.internalEndpoint)
+    const upstreamNode = minioUrl.host
+    const upstreamHost = bucketDomain
+
+    const id = `${website['_id']}`
+    const name = `website-${id}`
+    const data = {
+      name: name,
+      labels: {
+        customDomain: website.isCustom ? 'true' : 'false',
+        type: 'website',
+      },
+      uri: '/*',
+      hosts: [host],
+      priority: 20,
+      upstream: {
+        type: 'roundrobin',
+        pass_host: 'rewrite',
+        upstream_host: upstreamHost,
+        nodes: {
+          [upstreamNode]: 1,
+        },
+      },
+      timeout: {
+        connect: 60,
+        send: 60,
+        read: 60,
+      },
+      plugins: {
+        'proxy-rewrite': {
+          regex_uri: ['/$', '/index.html'],
+        },
+      },
+    }
+
+    const res = await this.putRoute(region, id, data)
+    return res
+  }
+
+  async deleteWebsiteRoute(region: Region, website: WebsiteHosting) {
+    const id = `${website['_id']}`
+    const res = await this.deleteRoute(region, id)
+    return res
+  }
+
   async putRoute(region: Region, id: string, data: any) {
     const conf = region.gatewayConf
     const api_url = `${conf.apiUrl}/routes/${id}`
 
-    const res = await this.httpService.axiosRef.put(api_url, data, {
-      headers: {
-        'X-API-KEY': conf.apiKey,
-        'Content-Type': 'application/json',
-      },
-    })
-
-    return res.data
+    try {
+      const res = await this.httpService.axiosRef.put(api_url, data, {
+        headers: {
+          'X-API-KEY': conf.apiKey,
+          'Content-Type': 'application/json',
+        },
+      })
+      return res.data
+    } catch (error) {
+      this.logger.error(error, error.response.data)
+      return null
+    }
   }
 
   async deleteRoute(region: Region, id: string) {
diff --git a/server/src/gateway/website-task.service.ts b/server/src/gateway/website-task.service.ts
@@ -1,19 +1,31 @@
 import { Injectable, Logger } from '@nestjs/common'
 import { Cron, CronExpression } from '@nestjs/schedule'
-import { DomainPhase, DomainState, WebsiteHosting } from '@prisma/client'
+import {
+  BucketDomain,
+  DomainPhase,
+  DomainState,
+  WebsiteHosting,
+} from '@prisma/client'
 import { times } from 'lodash'
 import { TASK_LOCK_INIT_TIME } from 'src/constants'
 import { SystemDatabase } from 'src/database/system-database'
+import { RegionService } from 'src/region/region.service'
+import * as assert from 'node:assert'
+import { ApisixService } from './apisix.service'
 
 @Injectable()
 export class WebsiteTaskService {
   readonly lockTimeout = 30 // in second
   readonly concurrency = 1 // concurrency count
   private readonly logger = new Logger(WebsiteTaskService.name)
 
+  constructor(
+    private readonly regionService: RegionService,
+    private readonly apisixService: ApisixService,
+  ) {}
+
   @Cron(CronExpression.EVERY_SECOND)
   async tick() {
-    return
     // Phase `Creating` -> `Created`
     times(this.concurrency, () => this.handleCreatingPhase())
 
@@ -41,7 +53,7 @@ export class WebsiteTaskService {
   async handleCreatingPhase() {
     const db = SystemDatabase.db
 
-    const doc = await db
+    const res = await db
       .collection<WebsiteHosting>('WebsiteHosting')
       .findOneAndUpdate(
         {
@@ -57,10 +69,50 @@ export class WebsiteTaskService {
         },
       )
 
-    if (doc.value) {
-      // TODO
-      // create website route
-      // update phase to `Created`
+    if (!res.value) return
+
+    this.logger.debug(res.value)
+    // get region by appid
+    const site = res.value
+    const region = await this.regionService.findByAppId(site.appid)
+    assert(region, 'region not found')
+
+    // get bucket domain
+    const bucketDomain = await db
+      .collection<BucketDomain>('BucketDomain')
+      .findOne({
+        appid: site.appid,
+        bucketName: site.bucketName,
+      })
+
+    assert(bucketDomain, 'bucket domain not found')
+
+    // create website route
+    const route = await this.apisixService.createWebsiteRoute(
+      region,
+      site,
+      bucketDomain.domain,
+    )
+    this.logger.debug(`create website route: `, route)
+
+    // update phase to `Created`
+    const updated = await db
+      .collection<WebsiteHosting>('WebsiteHosting')
+      .updateOne(
+        {
+          _id: site._id,
+          phase: DomainPhase.Creating,
+        },
+        {
+          $set: {
+            phase: DomainPhase.Created,
+            lockedAt: TASK_LOCK_INIT_TIME,
+          },
+        },
+      )
+
+    if (updated.modifiedCount !== 1) {
+      this.logger.error(`update website hosting phase failed: ${site._id}`)
     }
   }
 
@@ -72,7 +124,7 @@ export class WebsiteTaskService {
   async handleDeletingPhase() {
     const db = SystemDatabase.db
 
-    const doc = await db
+    const res = await db
       .collection<WebsiteHosting>('WebsiteHosting')
       .findOneAndUpdate(
         {
@@ -88,10 +140,36 @@ export class WebsiteTaskService {
         },
       )
 
-    if (doc.value) {
-      // TODO
-      // delete website route
-      // update phase to `Deleted`
+    if (!res.value) return
+
+    // get region by appid
+    const site = res.value
+    const region = await this.regionService.findByAppId(site.appid)
+    assert(region, 'region not found')
+
+    // delete website route
+    const route = await this.apisixService.deleteWebsiteRoute(region, site)
+
+    this.logger.debug(`delete website route: `, route)
+
+    // update phase to `Deleted`
+    const updated = await db
+      .collection<WebsiteHosting>('WebsiteHosting')
+      .updateOne(
+        {
+          _id: site._id,
+          phase: DomainPhase.Deleting,
+        },
+        {
+          $set: {
+            phase: DomainPhase.Deleted,
+            lockedAt: TASK_LOCK_INIT_TIME,
+          },
+        },
+      )
+
+    if (updated.modifiedCount > 1) {
+      this.logger.error(`update website hosting phase failed: ${site._id}`)
     }
   }
 
diff --git a/server/src/storage/storage.service.ts b/server/src/storage/storage.service.ts
@@ -22,18 +22,25 @@ export class StorageService {
     const accessKey = appid
     const secretKey = GenerateAlphaNumericPassword(64)
 
-    // create storage user in minio
-    const r0 = await this.minioService.createUser(region, accessKey, secretKey)
-    if (r0.error) {
-      this.logger.error(r0.error)
-      return false
+    // create storage user in minio if not exists
+    const minioUser = await this.minioService.getUser(region, accessKey)
+    if (!minioUser) {
+      const r0 = await this.minioService.createUser(
+        region,
+        accessKey,
+        secretKey,
+      )
+      if (r0.error) {
+        this.logger.error(r0.error)
+        return null
+      }
     }
 
     // add storage user to common user group in minio
     const r1 = await this.minioService.addUserToGroup(region, accessKey)
     if (r1.error) {
       this.logger.error(r1.error)
-      return false
+      return null
     }
 
     // create storage user in database
