@abtnode/core 1.16.52-beta-20251003-083412-fdfc4e36 → 1.16.52-beta-20251008-091027-c46c73e3

package/lib/blocklet/manager/disk.js

@@ -73,6 +73,7 @@ const { encrypt } = require('@blocklet/sdk/lib/security');
 const { generateRandomString } = require('@abtnode/models/lib/util');
 const { getComponentApiKey, getBlockletLogos } = require('@abtnode/util/lib/blocklet');
 const { getEmailServiceProvider, emailConfigSchema } = require('@abtnode/auth/lib/email');
+const { Joi } = require('@arcblock/validator');
 
 const {
   BlockletStatus,
@@ -134,6 +135,9 @@ const {
   refresh: refreshAccessibleExternalNodeIp,
   getFromCache: getAccessibleExternalNodeIp,
 } = require('../../util/get-accessible-external-node-ip');
+const { blueGreenStartBlocklet } = require('./helper/blue-green-start-blocklet.js');
+const { blueGreenUpgradeBlocklet } = require('./helper/blue-green-upgrade-blocklet.js');
+
 const {
   getAppSystemEnvironments,
   getComponentSystemEnvironments,
@@ -175,6 +179,7 @@ const {
   getPackConfig,
   copyPackImages,
   filterRequiredComponents,
+  getHookArgs,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
@@ -246,6 +251,7 @@ const { blockletThemeSchema } = require('../../validators/theme');
 const { removeDockerNetwork } = require('../../util/docker/docker-network.js');
 const parseDockerName = require('../../util/docker/parse-docker-name.js');
 const { verifyAigneConfig, decryptValue } = require('../../util/aigne-verify');
+const { blueGreenGetComponentIds } = require('./helper/blue-green-get-componentids.js');
 
 const { formatEnvironments, getBlockletMeta, validateOwner, isCLI } = util;
 
@@ -271,16 +277,6 @@ const USER_PROFILE_SYNC_FIELDS = [
   'phoneVerified',
 ];
 
-const getHookArgs = (blocklet) => ({
-  output: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '' : path.join(blocklet.env.logsDir, 'output.log'),
-  error: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '' : path.join(blocklet.env.logsDir, 'error.log'),
-  timeout:
-    Math.max(
-      get(blocklet, 'meta.timeout.script', 120),
-      ...(blocklet?.children || []).map((child) => child.meta?.timeout?.script || 0)
-    ) * 1000,
-});
-
 const pm2StatusMap = {
   online: BlockletStatus.running,
   stop: BlockletStatus.stopped,
@@ -730,7 +726,8 @@ class DiskBlockletManager extends BaseBlockletManager {
   }
 
   async checkComponentsForUpdates({ did }) {
-    await this.checkControllerStatus(await this.ensureBlocklet(did), 'upgrade');
+    const blocklet = await this.ensureBlocklet(did);
+    await this.checkControllerStatus(blocklet, 'upgrade');
     return UpgradeComponents.check({ did, states });
   }
 
@@ -876,6 +873,12 @@ class DiskBlockletManager extends BaseBlockletManager {
   ) {
     const operator = _operator || context?.user?.did;
 
+    try {
+      await this.deleteProcess({ did, componentDids, isGreen: true });
+    } catch {
+      // do nothing
+    }
+
     logger.info('start blocklet', {
       did: did || inputBlocklet.meta.did,
       componentDids,
@@ -1047,7 +1050,10 @@ class DiskBlockletManager extends BaseBlockletManager {
       });
 
       // check blocklet healthy
-      const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(blocklet, { checkHealthImmediately });
+      const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(blocklet, {
+        checkHealthImmediately,
+        componentDids,
+      });
       const params = {
         did,
         context,
@@ -1117,7 +1123,11 @@ class DiskBlockletManager extends BaseBlockletManager {
     const { processId } = blocklet.env;
 
     if (updateStatus) {
-      const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids, operator });
+      const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, {
+        componentDids,
+        operator,
+        isGreenAndBlue: true,
+      });
       blocklet.status = BlockletStatus.stopping;
       this.emit(BlockletEvents.statusChange, doc);
     }
@@ -1159,11 +1169,16 @@ class DiskBlockletManager extends BaseBlockletManager {
           });
         },
         componentDids,
+        isStopGreenAndBlue: true,
       });
     } catch (error) {
       logger.error('Failed to stop blocklet', { error, did });
       if (updateStatus) {
-        const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids, operator });
+        const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
+          componentDids,
+          operator,
+          isGreenAndBlue: true,
+        });
         this.emit(BlockletEvents.statusChange, res);
       }
       throw error;
@@ -1174,7 +1189,11 @@ class DiskBlockletManager extends BaseBlockletManager {
     launcher.notifyBlockletStopped(blocklet);
 
     if (updateStatus) {
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids, operator });
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+        componentDids,
+        operator,
+        isGreenAndBlue: true,
+      });
       // send notification to websocket channel
       this.emit(BlockletEvents.statusChange, res);
 
@@ -1286,10 +1305,7 @@ class DiskBlockletManager extends BaseBlockletManager {
     logger.info('restart blocklet', { did, operator });
     const blocklet = await this.getBlocklet(did);
     await this.checkControllerStatus(blocklet, 'restart');
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, {
-      componentDids,
-      operator,
-    });
+
     const result = await states.blocklet.getBlocklet(did);
     this.emit(BlockletEvents.statusChange, result);
 
@@ -1302,12 +1318,9 @@ class DiskBlockletManager extends BaseBlockletManager {
       operator,
       context,
     });
-    ticket.on('failed', async (err) => {
+    ticket.on('failed', (err) => {
       logger.error('failed to restart blocklet', { did, error: err });
 
-      const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids, operator });
-      this.emit(BlockletEvents.statusChange, state);
-
       const description = `${getComponentNamesWithVersion(result, componentDids)} restart failed for ${getDisplayName(
         result
       )}: ${err.message || 'queue exception'}`;
@@ -1640,20 +1653,23 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       const { name, did, version } = blocklet.meta;
 
-      if (![BlockletStatus.downloading, BlockletStatus.waiting].includes(blocklet.status)) {
+      if (
+        ![BlockletStatus.downloading, BlockletStatus.waiting].includes(blocklet.greenStatus) &&
+        ![BlockletStatus.downloading, BlockletStatus.waiting].includes(blocklet.status)
+      ) {
         throw new Error(`Can not cancel blocklet that status is ${fromBlockletStatus(blocklet.status)}`);
       }
 
       const job = await this.installQueue.get(did);
 
       // cancel job
-      if (blocklet.status === BlockletStatus.downloading) {
+      if (blocklet.greenStatus === BlockletStatus.downloading || blocklet.status === BlockletStatus.downloading) {
         try {
           await this.blockletDownloader.cancelDownload(blocklet.meta.did);
         } catch (error) {
           logger.error('failed to exec blockletDownloader.download', { did: blocklet.meta.did, error });
         }
-      } else if (blocklet.status === BlockletStatus.waiting) {
+      } else if (blocklet.greenStatus === BlockletStatus.waiting || blocklet.status === BlockletStatus.waiting) {
         try {
           await this.installQueue.cancel(blocklet.meta.did);
         } catch (error) {
@@ -1670,7 +1686,7 @@ class DiskBlockletManager extends BaseBlockletManager {
         if (data) {
           const { action, oldBlocklet } = data;
           await this._rollback(action, did, oldBlocklet);
-          await this._rollbackCache.remove({ did });
+          await this._rollbackCache.remove({ did: inputDid });
         } else {
           throw new Error(`Cannot find rollback data in queue or backup file of blocklet ${inputDid}`);
         }
@@ -1686,7 +1702,10 @@ class DiskBlockletManager extends BaseBlockletManager {
         if (blocklet) {
           const componentDids = [];
           forEachComponentV2Sync(blocklet, (x) => {
-            if ([BlockletStatus.waiting, BlockletStatus.downloading].includes(x.status)) {
+            if (
+              [BlockletStatus.waiting, BlockletStatus.downloading].includes(x.status) ||
+              [BlockletStatus.waiting, BlockletStatus.downloading].includes(x.greenStatus)
+            ) {
               componentDids.push(x.meta.did);
             }
           });
@@ -1712,23 +1731,23 @@ class DiskBlockletManager extends BaseBlockletManager {
    * @param {*} context
    * @returns
    */
-  async deleteProcess({ did, componentDids, shouldUpdateBlockletStatus = true }, context) {
+  deleteProcess = async ({ did, componentDids, shouldUpdateBlockletStatus = true, isGreen = false }, context) => {
     const blocklet = await this.getBlocklet(did);
 
     logger.info('delete blocklet process', { did, componentDids });
 
-    await deleteBlockletProcess(blocklet, { ...context, componentDids });
+    await deleteBlockletProcess(blocklet, { ...context, componentDids, isGreen });
     logger.info('blocklet process deleted successfully', { did, componentDids });
 
     // 有些情况不需要更新 blocklet 状态, 比如下载完成，安装之前清理 process 时, 不需要更新 blocklet 状态
     if (shouldUpdateBlockletStatus) {
-      const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids });
+      const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids, isGreen });
       logger.info('blocklet status updated to stopped after deleted processes', { did, componentDids });
       return result;
     }
 
     return blocklet;
-  }
+  };
 
   // Get blocklet by blockletDid or appDid
   async detail(
@@ -2907,7 +2926,7 @@ class DiskBlockletManager extends BaseBlockletManager {
     return summary;
   }
 
-  async updateBlockletSettings({ did, enableSessionHardening, invite, gateway, aigne }, context) {
+  async updateBlockletSettings({ did, enableSessionHardening, invite, gateway, aigne, org }, context) {
     const params = {};
     if (!isNil(enableSessionHardening)) {
       params.enableSessionHardening = enableSessionHardening;
@@ -2939,6 +2958,26 @@ class DiskBlockletManager extends BaseBlockletManager {
         url: getOriginUrl(aigne.url),
       };
     }
+
+    let shouldRotateSession = false;
+    if (!isNil(org)) {
+      const ORG_SCHEMA = Joi.object({
+        enabled: Joi.boolean().required(),
+        maxMemberPerOrg: Joi.number().required().min(2).default(100),
+        maxOrgPerUser: Joi.number().required().min(1).default(10),
+      });
+      const { error } = ORG_SCHEMA.validate(org);
+      if (error) {
+        throw new CustomError(400, error.message);
+      }
+      const currentState = await this.getBlocklet(did, { useCache: true });
+      const orgEnabled = get(currentState, 'settings.org.enabled', false);
+      if (orgEnabled !== org.enabled) {
+        shouldRotateSession = true;
+      }
+      params.org = org;
+    }
+
     const keys = Object.keys(params);
     if (!keys.length) {
       throw new Error('No settings to update');
@@ -2956,6 +2995,10 @@ class DiskBlockletManager extends BaseBlockletManager {
     this.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
     this.emit(BlockletEvents.updated, { ...newState, context });
 
+    if (shouldRotateSession) {
+      this.teamAPI.rotateSessionKey({ teamDid: did });
+    }
+
     return newState;
   }
 
@@ -3208,7 +3251,22 @@ class DiskBlockletManager extends BaseBlockletManager {
       return x;
     });
 
+    const blueGreenComponentIds = await blueGreenGetComponentIds(oldBlocklet || blocklet, componentDids);
+
     try {
+      await Promise.all(
+        blueGreenComponentIds.map(async (item) => {
+          if (item.componentDids.length === 0) {
+            return;
+          }
+          await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
+            componentDids: item.componentDids,
+            isGreen: item.changeToGreen,
+          });
+        })
+      );
+      const state = await states.blocklet.getBlocklet(did);
+      this.emit(BlockletEvents.statusChange, state);
       const { isCancelled } = await this._downloadBlocklet(
         {
           ...blocklet,
@@ -3269,8 +3327,10 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       // rollback on download failed
       await statusLock.acquire('rollback-on-download-failed');
+
       try {
-        if ((await states.blocklet.getBlockletStatus(did)) === BlockletStatus.downloading) {
+        const status = await states.blocklet.getBlockletStatus(did);
+        if ([BlockletStatus.downloading, BlockletStatus.waiting].includes(status)) {
           await this._rollback(postAction, did, oldBlocklet);
         }
       } catch (error) {
@@ -3289,25 +3349,38 @@ class DiskBlockletManager extends BaseBlockletManager {
     // update status
     await statusLock.acquire('download-update-status');
     try {
-      if ((await states.blocklet.getBlockletStatus(did)) !== BlockletStatus.downloading) {
-        throw new Error('blocklet status changed durning download');
-      }
+      await Promise.all(
+        blueGreenComponentIds.map(async (item) => {
+          if (item.componentDids.length === 0) {
+            return;
+          }
+          if ((await states.blocklet.getBlockletStatus(did)) !== BlockletStatus.downloading) {
+            throw new Error('blocklet status changed durning download');
+          }
 
-      if (postAction === INSTALL_ACTIONS.INSTALL) {
-        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.installing, { componentDids });
-        this.emit(BlockletEvents.statusChange, state);
-      }
+          if (postAction === INSTALL_ACTIONS.INSTALL) {
+            const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.installing, {
+              componentDids: item.componentDids,
+              isGreen: item.changeToGreen,
+            });
+            this.emit(BlockletEvents.statusChange, state);
+          }
 
-      if (
-        [
-          INSTALL_ACTIONS.INSTALL_COMPONENT,
-          INSTALL_ACTIONS.UPGRADE_COMPONENT,
-          'upgrade', // for backward compatibility
-        ].includes(postAction)
-      ) {
-        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading, { componentDids });
-        this.emit(BlockletEvents.statusChange, state);
-      }
+          if (
+            [
+              INSTALL_ACTIONS.INSTALL_COMPONENT,
+              INSTALL_ACTIONS.UPGRADE_COMPONENT,
+              'upgrade', // for backward compatibility
+            ].includes(postAction)
+          ) {
+            const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading, {
+              componentDids: item.componentDids,
+              isGreen: item.changeToGreen,
+            });
+            this.emit(BlockletEvents.statusChange, state);
+          }
+        })
+      );
     } catch (error) {
       logger.error(error.message);
     } finally {
@@ -3335,15 +3408,30 @@ class DiskBlockletManager extends BaseBlockletManager {
         logger.info('do upgrade blocklet', { did, version, postAction, componentDids });
 
         try {
-          await this._upgradeBlocklet({
-            newBlocklet: blocklet,
-            oldBlocklet,
-            componentDids,
-            context,
-            action: postAction,
-            shouldCleanUploadFile,
-            url,
-          });
+          if (postAction === INSTALL_ACTIONS.UPGRADE_COMPONENT) {
+            await blueGreenUpgradeBlocklet(
+              {
+                newBlocklet: blocklet,
+                oldBlocklet,
+                componentDids,
+                action: postAction,
+                shouldCleanUploadFile,
+                url,
+              },
+              context,
+              this,
+              states
+            );
+          } else {
+            await this._upgradeBlocklet({
+              newBlocklet: blocklet,
+              oldBlocklet,
+              componentDids,
+              action: postAction,
+              shouldCleanUploadFile,
+              url,
+            });
+          }
 
           const newBlocklet = await this.getBlocklet(did);
 
@@ -3402,11 +3490,13 @@ class DiskBlockletManager extends BaseBlockletManager {
   }
 
   async _onRestart({ did, componentDids, context, operator }) {
-    await this.stop({ did, componentDids, updateStatus: false, operator }, context);
-    await this.start({ did, componentDids, operator }, context);
+    await blueGreenStartBlocklet({ did, componentDids, operator }, context, this, states);
   }
 
-  async _onCheckIfStarted(jobInfo, { throwOnError, skipRunningCheck = false } = {}) {
+  _onCheckIfStarted = async (
+    jobInfo,
+    { throwOnError, skipRunningCheck = false, isGreen = false, needUpdateBlueStatus = true } = {}
+  ) => {
     const startedAt = Date.now();
     const { did, context, minConsecutiveTime = 2000, timeout, componentDids } = jobInfo;
     const blocklet = await this.getBlocklet(did);
@@ -3415,38 +3505,73 @@ class DiskBlockletManager extends BaseBlockletManager {
     const { name } = meta;
 
     const nodeInfo = await states.node.read();
+    const successBlockletIds = new Set();
     try {
       if (!skipRunningCheck) {
         await checkBlockletProcessHealthy(blocklet, {
           minConsecutiveTime,
           timeout,
           componentDids,
+          isGreen,
           enableDocker: nodeInfo.enableDocker,
           setBlockletRunning: async (componentDid) => {
-            await states.blocklet.setBlockletStatus(did, BlockletStatus.running, { componentDids: [componentDid] });
+            successBlockletIds.add(componentDid);
+            await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
+              componentDids: [componentDid],
+              isGreen,
+            });
           },
         });
       }
 
-      const runningRes = await states.blocklet.setBlockletStatus(did, BlockletStatus.running, { componentDids });
+      const runningRes = await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
+        componentDids: successBlockletIds.size > 0 ? Array.from(successBlockletIds) : componentDids,
+        isGreen,
+      });
 
-      const res = await this.getBlocklet(did);
+      if (needUpdateBlueStatus) {
+        await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+          componentDids,
+          isGreen: !isGreen,
+        });
+      }
 
+      const nextBlocklet = await this.getBlocklet(did);
+
+      await this.configSynchronizer.throttledSyncAppConfig(nextBlocklet);
+      const componentsInfo = getComponentsInternalInfo(nextBlocklet);
       this.emit(BlockletInternalEvents.componentStarted, {
         appDid: blocklet.appDid,
-        components: (componentDids || []).map((x) => ({ did: x })),
+        components: componentsInfo,
       });
-      this.configSynchronizer.throttledSyncAppConfig(res);
 
-      this.emit(BlockletEvents.statusChange, res);
-      this.emit(BlockletEvents.started, { ...res, componentDids });
+      this.emit(BlockletEvents.statusChange, nextBlocklet);
+      this.emit(BlockletEvents.started, { ...nextBlocklet, componentDids });
 
       launcher.notifyBlockletStarted(blocklet);
 
       logger.info('blocklet healthy', { did, name, time: Date.now() - startedAt });
 
+      if (needUpdateBlueStatus) {
+        try {
+          await this.deleteProcess({ did, componentDids, isGreen: !isGreen }, context);
+        } catch {
+          logger.error('delete process failed', { did, componentDids, isGreen });
+        }
+      }
+
       return runningRes;
     } catch (error) {
+      const errorBlockletIds = [];
+      for (const componentDid of componentDids) {
+        if (!successBlockletIds.has(componentDid)) {
+          errorBlockletIds.push(componentDid);
+        }
+      }
+      if (errorBlockletIds.length === 0) {
+        return this.getBlocklet(did);
+      }
+
       const status = await states.blocklet.getBlockletStatus(did);
       if ([BlockletStatus.stopping, BlockletStatus.stopped].includes(status)) {
         logger.info(`Check blocklet healthy failing because blocklet is ${fromBlockletStatus(status)}`);
@@ -3455,12 +3580,21 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       logger.error('check blocklet if started failed', { did, name, context, timeout, error });
 
-      await this.deleteProcess({ did, componentDids }, context);
-      const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
+      await this.deleteProcess({ did, componentDids: errorBlockletIds, isGreen }, context);
 
-      const componentNames = getComponentNamesWithVersion(blocklet, componentDids);
+      let doc;
+      if (isGreen) {
+        doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+          componentDids: errorBlockletIds,
+          isGreen,
+        });
+      } else {
+        doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids: errorBlockletIds });
+      }
+
+      const componentNames = getComponentNamesWithVersion(blocklet, errorBlockletIds);
       const description = componentNames
-        ? `${getComponentNamesWithVersion(blocklet, componentDids)} start failed for ${getDisplayName(blocklet)}: ${
+        ? `${getComponentNamesWithVersion(blocklet, errorBlockletIds)} start failed for ${getDisplayName(blocklet)}: ${
             error.message
           }`
         : `${blocklet.meta.title} start failed: ${error.message}`;
@@ -3473,7 +3607,11 @@ class DiskBlockletManager extends BaseBlockletManager {
         severity: 'error',
       });
 
-      this.emit(BlockletEvents.startFailed, { ...doc, componentDids, error: { message: error.message } });
+      this.emit(BlockletEvents.startFailed, {
+        ...doc,
+        componentDids: errorBlockletIds,
+        error: { message: error.message },
+      });
       this.emit(BlockletEvents.statusChange, { ...doc, error });
 
       if (throwOnError) {
@@ -3482,7 +3620,7 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       return doc;
     }
-  }
+  };
 
   /**
    * @param {{
@@ -4401,7 +4539,7 @@ class DiskBlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _runMigration({ needRunDocker, did, blocklet, oldBlocklet, componentDids }) {
+  async _runMigration({ parallel, did, blocklet, oldBlocklet, componentDids }) {
     logger.info('start migration on upgrading', { did, componentDids });
     const oldVersions = {};
     forEachComponentV2Sync(oldBlocklet, (b) => {
@@ -4471,8 +4609,8 @@ class DiskBlockletManager extends BaseBlockletManager {
       }
     };
     await forEachComponentV2(blocklet, runMigration, {
-      parallel: !needRunDocker,
-      concurrencyLimit: needRunDocker ? 1 : 4,
+      parallel,
+      concurrencyLimit: parallel ? 4 : 1,
     });
     logger.info('done migration on upgrading', { did, componentDids });
   }
@@ -4530,7 +4668,7 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       await this._runUserHook('preFlight', blocklet, context);
 
-      await this._runMigration({ needRunDocker, did, blocklet, oldBlocklet, componentDids });
+      await this._runMigration({ parallel: !needRunDocker, did, blocklet, oldBlocklet, componentDids });
 
       // handle component status
       const runningDids = [];
@@ -4696,15 +4834,7 @@ class DiskBlockletManager extends BaseBlockletManager {
 
     return this.blockletDownloader.download(blocklet, {
       ...context,
-      preDownload: async ({ downloadComponentIds }) => {
-        // update children status
-        if (downloadComponentIds?.length) {
-          const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
-            componentDids: downloadComponentIds,
-          });
-          this.emit(BlockletEvents.statusChange, blocklet1);
-        }
-      },
+      // preDownload: () => {},
       onProgress: (data) => {
         this.emit(BlockletEvents.downloadBundleProgress, { appDid: appDid || did, meta: { did }, ...data });
       },

package/lib/blocklet/manager/ensure-blocklet-running.js

@@ -177,7 +177,8 @@ class EnsureBlockletRunning {
       const { did } = rootBlocklet.meta;
       if (rootBlocklet.children) {
         for (const childBlocklet of rootBlocklet.children) {
-          const isRunning = runningStatuses.includes(childBlocklet.status);
+          const isRunning =
+            runningStatuses.includes(childBlocklet.status) || childBlocklet.greenStatus === BlockletStatus.running;
           const isInProgress = inProgressStatuses.includes(childBlocklet.status);
           if (isRunning || isInProgress) {
             if (!this.runningBlocklets[did]) {
@@ -207,7 +208,7 @@ class EnsureBlockletRunning {
               return async () => {
                 if (!shouldCheckHealthy(blocklet)) {
                   // 如果 blocklet 是不需要启动的，并且不是 running，则设置为 running 状态
-                  if (blocklet.status !== BlockletStatus.running) {
+                  if (blocklet.status !== BlockletStatus.running && blocklet.greenStatus !== BlockletStatus.running) {
                     await this.states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
                       componentDids: [blocklet.meta.did],
                     });

package/lib/blocklet/manager/helper/blue-green-get-componentids.js

@@ -0,0 +1,59 @@
+const { BlockletStatus } = require('../../../states/blocklet');
+const { forEachBlocklet } = require('../../../util/blocklet');
+
+const blueGreenGetComponentIds = async (blocklet, componentDids) => {
+  if (!blocklet) {
+    return {
+      componentDids: componentDids || [],
+      changeToGreen: false,
+    };
+  }
+  const componentDidsSet = new Set(componentDids);
+  const runningStatuses = new Set([BlockletStatus.running]);
+  const greenComponentIds = [];
+  const blueComponentIds = [];
+
+  const activeStatuses = new Set([BlockletStatus.running, BlockletStatus.starting]);
+  const children = blocklet.children || [];
+  const hasActiveInstance =
+    activeStatuses.has(blocklet.status) ||
+    activeStatuses.has(blocklet.greenStatus) ||
+    children.some((child) => activeStatuses.has(child.status) || activeStatuses.has(child.greenStatus));
+
+  if (!hasActiveInstance) {
+    return [
+      {
+        componentDids: Array.from(componentDidsSet),
+        changeToGreen: false,
+      },
+    ];
+  }
+
+  await forEachBlocklet(
+    blocklet,
+    (b) => {
+      if (!componentDidsSet.has(b.meta.did)) {
+        return;
+      }
+      if (runningStatuses.has(b.greenStatus)) {
+        greenComponentIds.push(b.meta.did);
+      } else {
+        blueComponentIds.push(b.meta.did);
+      }
+    },
+    { parallel: true, concurrencyLimit: 10 }
+  );
+
+  return [
+    {
+      componentDids: greenComponentIds,
+      changeToGreen: false,
+    },
+    {
+      componentDids: blueComponentIds,
+      changeToGreen: true,
+    },
+  ];
+};
+
+module.exports = { blueGreenGetComponentIds };