@abtnode/core 1.17.3-beta-20251120-052956-035abea6 → 1.17.3-beta-20251123-232619-53258789

package/lib/blocklet/manager/helper/blue-green-start-blocklet.js

@@ -10,6 +10,7 @@ const {
 } = require('@blocklet/meta/lib/util');
 const { getBlockletEngine, hasStartEngine } = require('@blocklet/meta/lib/engine');
 const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
+const pAll = require('p-all');
 const {
   forEachBlocklet,
   validateBlocklet,
@@ -18,6 +19,7 @@ const {
   getHealthyCheckTimeout,
   getHookArgs,
   shouldSkipComponent,
+  getComponentNamesWithVersion,
 } = require('../../../util/blocklet');
 const { startBlockletProcess } = require('../../../util/blocklet');
 const hooks = require('../../hooks');
@@ -39,7 +41,7 @@ const { isDockerOnlySingleInstance } = require('../../../util/docker/is-docker-o
  * @returns {Promise<Object>} 返回启动后的 blocklet 对象
  */
 const blueGreenStartBlocklet = async (
-  { did, componentDids, operator: _operator, ignoreErrorNotification },
+  { did, componentDids, operator: _operator, ignoreErrorNotification, onError },
   context,
   manager,
   states
@@ -169,143 +171,260 @@ const blueGreenStartBlocklet = async (
 
   const blueGreenComponentIds = await blueGreenGetComponentIds(blocklet1, entryComponentIds);
 
-  // eslint-disable-next-line no-unreachable-loop
+  const startedBlockletDids = [];
+  const errorBlockletDids = [];
+
   for (const item of blueGreenComponentIds) {
     if (!item.componentDids.length) {
       continue;
     }
 
-    try {
-      const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, {
-        componentDids: item.componentDids,
-        operator,
-        isGreen: item.changeToGreen,
-      });
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, {
+      componentDids: item.componentDids,
+      operator,
+      isGreen: item.changeToGreen,
+    });
 
-      const nextBlocklet = await ensureAppPortsNotOccupied({
-        blocklet: blocklet1,
-        componentDids: item.componentDids,
-        states,
-        manager,
-        isGreen: item.changeToGreen,
-      });
+    await ensureAppPortsNotOccupied({
+      blocklet: blocklet1,
+      componentDids: item.componentDids,
+      states,
+      manager,
+      isGreen: item.changeToGreen,
+    });
+  }
 
-      manager.emit(BlockletEvents.statusChange, doc1);
+  const nextBlocklet = await manager.ensureBlocklet(did, { e2eMode });
 
-      const nodeInfo = await states.node.read();
-      const nodeEnvironments = await states.node.getEnvironments();
+  manager.emit(BlockletEvents.statusChange, nextBlocklet);
 
-      // 钩子函数设置
-      const getHookFn =
-        (hookName) =>
-        async (b, { env }) => {
-          const hookArgs = getHookArgs(b);
-          const needRunDocker = await checkNeedRunDocker(b.meta, env, nodeInfo, isExternalBlocklet(nextBlocklet));
-          if (!b.meta.scripts?.[hookName]) {
-            return null;
-          }
-          if (needRunDocker) {
-            return dockerExec({
-              blocklet: nextBlocklet,
-              meta: b.meta,
-              script: b.meta.scripts?.[hookName],
-              hookName,
-              nodeInfo,
-              env,
-              ...hookArgs,
-            });
-          }
-          return hooks[hookName](b, {
-            appDir: b.env.appDir,
-            hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env,
-            did, // root blocklet did,
-            teamManager: manager.teamManager,
-            ...hookArgs,
+  // 收集所有任务
+  const tasks = [];
+  for (const item of blueGreenComponentIds) {
+    if (!item.componentDids.length) {
+      continue;
+    }
+
+    for (const subDid of item.componentDids) {
+      tasks.push(async () => {
+        try {
+          const nodeInfo = await states.node.read();
+          const nodeEnvironments = await states.node.getEnvironments();
+
+          // 钩子函数设置
+          const getHookFn =
+            (hookName) =>
+            async (b, { env }) => {
+              const hookArgs = getHookArgs(b);
+              const needRunDocker = await checkNeedRunDocker(b.meta, env, nodeInfo, isExternalBlocklet(nextBlocklet));
+              if (!b.meta.scripts?.[hookName]) {
+                return null;
+              }
+              if (needRunDocker) {
+                return dockerExec({
+                  blocklet: nextBlocklet,
+                  meta: b.meta,
+                  script: b.meta.scripts?.[hookName],
+                  hookName,
+                  nodeInfo,
+                  env,
+                  ...hookArgs,
+                });
+              }
+              return hooks[hookName](b, {
+                appDir: b.env.appDir,
+                hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+                env,
+                did, // root blocklet did,
+                teamManager: manager.teamManager,
+                ...hookArgs,
+              });
+            };
+
+          await startBlockletProcess(nextBlocklet, {
+            ...context,
+            preFlight: getHookFn('preFlight'),
+            preStart: getHookFn('preStart'),
+            postStart: getHookFn('postStart'),
+            nodeEnvironments,
+            nodeInfo,
+            e2eMode,
+            componentDids: [subDid],
+            configSynchronizer: manager.configSynchronizer,
+            isGreen: item.changeToGreen,
+          });
+
+          // 健康检查绿色环境
+          const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(nextBlocklet, {
+            checkHealthImmediately,
+            componentDids: [subDid],
+          });
+
+          await manager._onCheckIfStarted(
+            {
+              did,
+              context,
+              minConsecutiveTime,
+              timeout: startTimeout,
+              componentDids: [subDid],
+            },
+            { throwOnError: true, isGreen: item.changeToGreen }
+          );
+
+          // 收集成功的组件（排除已经在 errorBlockletDids 中的组件）
+          startedBlockletDids.push({ did: subDid, isGreen: item.changeToGreen });
+
+          logger.info('Green environment started successfully', {
+            did,
+            componentDids: [subDid],
           });
-        };
-
-      await startBlockletProcess(nextBlocklet, {
-        ...context,
-        preFlight: getHookFn('preFlight'),
-        preStart: getHookFn('preStart'),
-        postStart: getHookFn('postStart'),
-        nodeEnvironments,
-        nodeInfo,
-        e2eMode,
-        componentDids: item.componentDids,
-        configSynchronizer: manager.configSynchronizer,
-        isGreen: item.changeToGreen,
+        } catch (err) {
+          const error = Array.isArray(err) ? err[0] : err;
+          logger.error('Failed to start green environment', { error, did, title: blocklet1.meta.title });
+
+          // 收集失败的组件
+          errorBlockletDids.push({ did: subDid, error, isGreen: item.changeToGreen });
+
+          try {
+            await manager.deleteProcess({ did, componentDids: [subDid], isGreen: item.changeToGreen });
+          } catch (cleanupError) {
+            logger.error('Failed to cleanup green environment', { cleanupError });
+          }
+        }
+      });
+    }
+  }
+
+  await pAll(tasks, { concurrency: 6 });
+
+  const lastBlocklet = await manager.ensureBlocklet(did, { e2eMode });
+  let errorDescription = '';
+
+  // 处理启动失败的组件
+  if (errorBlockletDids.length) {
+    const { error } = errorBlockletDids[0];
+    for (const item of errorBlockletDids) {
+      logger.error('Failed to start blocklet', {
+        error: item.error,
+        title: lastBlocklet.meta.title,
+        name: getComponentNamesWithVersion(lastBlocklet, [item.did]),
+      });
+    }
+
+    errorDescription = `${getComponentNamesWithVersion(
+      lastBlocklet,
+      errorBlockletDids.map((x) => x.did)
+    )} start failed for ${getDisplayName(lastBlocklet)}: ${errorBlockletDids.map((x) => x.error.message).join('. ')}`;
+
+    if (!ignoreErrorNotification) {
+      manager._createNotification(did, {
+        title: 'Blue-Green Deployment: Green Start Failed',
+        description: errorDescription,
+        entityType: 'blocklet',
+        entityId: did,
+        severity: 'error',
       });
+    }
+
+    const greenBlockletDids = errorBlockletDids.filter((x) => x.isGreen).map((x) => x.did);
+    const blueBlockletDids = errorBlockletDids.filter((x) => !x.isGreen).map((x) => x.did);
 
-      // 健康检查绿色环境
-      const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(nextBlocklet, {
-        checkHealthImmediately,
-        componentDids: item.componentDids,
+    if (greenBlockletDids.length) {
+      await manager.deleteProcess({
+        did,
+        componentDids: greenBlockletDids,
+        shouldUpdateBlockletStatus: false,
+        isGreen: true,
+      });
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
+        componentDids: greenBlockletDids,
+        operator,
+        isGreen: true,
       });
+    }
 
-      await manager._onCheckIfStarted(
-        {
-          did,
-          context,
-          minConsecutiveTime,
-          timeout: startTimeout,
-          componentDids: item.componentDids,
-        },
-        { throwOnError: true, isGreen: item.changeToGreen, needUpdateBlueStatus: true }
-      );
-
-      logger.info('Green environment started successfully', {
+    if (blueBlockletDids.length) {
+      await manager.deleteProcess({
         did,
-        componentDids: item.componentDids,
+        componentDids: blueBlockletDids,
+        shouldUpdateBlockletStatus: false,
+        isGreen: false,
       });
-    } catch (err) {
-      const error = Array.isArray(err) ? err[0] : err;
-      logger.error('Failed to start green environment', { error, did, title: blocklet1.meta.title });
-
-      try {
-        await manager.deleteProcess({ did, componentDids: item.componentDids, isGreen: item.changeToGreen });
-        // 如果需要把失败状态设置成 error:
-        // const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-        //   componentDids: item.componentDids,
-        //   operator,
-        //   isGreen: item.changeToGreen,
-        // });
-        // manager.emit(BlockletEvents.statusChange, doc1);
-        manager.emit(BlockletEvents.statusChange, blocklet1);
-      } catch (cleanupError) {
-        logger.error('Failed to cleanup green environment', { cleanupError });
-      }
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
+        componentDids: blueBlockletDids,
+        operator,
+        isGreen: false,
+      });
+    }
 
-      const description = `Green environment start failed for ${getDisplayName(blocklet1)}: ${error.message}`;
-      if (!ignoreErrorNotification) {
-        manager._createNotification(did, {
-          title: 'Blue-Green Deployment: Green Start Failed',
-          description,
-          entityType: 'blocklet',
-          entityId: did,
-          severity: 'error',
-        });
-      }
+    const finalBlocklet = await manager.getBlocklet(did);
+    manager.emit(BlockletEvents.startFailed, {
+      ...finalBlocklet,
+      componentDids: errorBlockletDids.map((x) => x.did),
+      error: { message: error.message },
+    });
+    manager.emit(BlockletEvents.statusChange, { ...finalBlocklet, error: { message: error.message } });
+  }
 
-      if (throwOnError) {
-        throw new Error(description);
-      }
-      throw error;
+  // 处理成功启动的组件
+  if (startedBlockletDids.length) {
+    const startedGreenBlockletDids = startedBlockletDids.filter((x) => x.isGreen).map((x) => x.did);
+    const startedBlueBlockletDids = startedBlockletDids.filter((x) => !x.isGreen).map((x) => x.did);
+
+    if (startedGreenBlockletDids.length) {
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
+        componentDids: startedGreenBlockletDids,
+        operator,
+        isGreen: true,
+      });
+      await manager.deleteProcess({ did, componentDids: startedGreenBlockletDids, isGreen: false });
+    }
+
+    if (startedBlueBlockletDids.length) {
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
+        componentDids: startedBlueBlockletDids,
+        operator,
+        isGreen: false,
+      });
+      await manager.deleteProcess({ did, componentDids: startedBlueBlockletDids, isGreen: true });
     }
 
-    const nextBlocklet = await manager.ensureBlocklet(did, { e2eMode });
-    manager.emit(BlockletEvents.blurOrGreenStarted, { blocklet: nextBlocklet, componentDids, context });
+    const finalBlocklet = await manager.getBlocklet(did);
+
+    await manager.configSynchronizer.throttledSyncAppConfig(finalBlocklet);
+    const componentsInfo = getComponentsInternalInfo(finalBlocklet);
+    manager.emit(BlockletInternalEvents.componentUpdated, {
+      appDid: blocklet1.appDid,
+      components: componentsInfo,
+    });
+    manager.emit(BlockletInternalEvents.componentStarted, {
+      appDid: blocklet1.appDid,
+      components: startedBlockletDids.map((x) => ({ did: x.did })),
+    });
+
+    manager.emit(BlockletEvents.statusChange, finalBlocklet);
+    manager.emit(BlockletEvents.started, {
+      ...finalBlocklet,
+      componentDids: startedBlockletDids.map((x) => x.did),
+    });
   }
 
-  const nextBlocklet = await manager.getBlocklet(did);
-  const componentsInfo = getComponentsInternalInfo(nextBlocklet);
-  manager.emit(BlockletInternalEvents.componentStarted, {
-    appDid: nextBlocklet.appDid,
-    components: componentsInfo,
-  });
+  // 根据情况更新 route table， 会判断只有包含多 interfaces 的 DID 才会更新 route table
+  if (!['true', '1'].includes(process.env.ABT_NODE_DISABLE_BLUE_GREEN)) {
+    manager.emit(BlockletEvents.blurOrGreenStarted, {
+      blocklet: lastBlocklet,
+      componentDids,
+      context,
+    });
+  }
 
-  manager.emit(BlockletEvents.statusChange, nextBlocklet);
+  if (errorBlockletDids.length && onError) {
+    onError(errorBlockletDids);
+  }
+
+  if (throwOnError && errorDescription) {
+    throw new Error(errorDescription);
+  }
 };
 
 module.exports = {

package/lib/blocklet/manager/helper/blue-green-upgrade-blocklet.js

@@ -28,6 +28,8 @@ const blueGreenUpgradeBlocklet = async (
     }
   }
 
+  let errorBlockletDids = [];
+
   try {
     await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
     logger.info('updated blocklet for upgrading', { did, componentDids, source, name });
@@ -81,7 +83,15 @@ const blueGreenUpgradeBlocklet = async (
     if (runningDids.length) {
       if (initialized) {
         await blueGreenStartBlocklet(
-          { did, componentDids: runningDids, operator: context?.user?.did, ignoreErrorNotification: true },
+          {
+            did,
+            componentDids: runningDids,
+            operator: context?.user?.did,
+            ignoreErrorNotification: true,
+            onError: (dids) => {
+              errorBlockletDids = dids;
+            },
+          },
           context,
           manager,
           states
@@ -158,9 +168,45 @@ const blueGreenUpgradeBlocklet = async (
     return blocklet;
   } catch (err) {
     logger.error('failed to upgrade blocklet', { did, version, name, error: err });
-    await states.blocklet.upgradeBlocklet({ ...oldBlocklet });
-    manager.configSynchronizer.throttledSyncAppConfig(oldBlocklet);
+    const nextBlocklet = await manager.ensureBlocklet(did);
+
+    // 提取出错的 blocklet did 列表
+    let errorDids = [];
+    if (Array.isArray(errorBlockletDids) && errorBlockletDids.length > 0) {
+      if (typeof errorBlockletDids[0] === 'string') {
+        errorDids = errorBlockletDids;
+      } else {
+        errorDids = errorBlockletDids.map((x) => x.did);
+      }
+    }
+
+    const rollbackBlocklet = { ...oldBlocklet };
+    for (const child of nextBlocklet.children) {
+      const isErrorBlocklet = errorDids.includes(child.meta.did);
+      if (isErrorBlocklet) {
+        for (const oldChild of oldBlocklet.children) {
+          if (child && oldChild && child.meta.did === oldChild.meta.did) {
+            const rollbackChild = rollbackBlocklet.children.find((c) => c.meta.did === child.meta.did);
+            if (rollbackChild) {
+              rollbackChild.status = oldChild.status;
+              rollbackChild.greenStatus = oldChild.greenStatus;
+              rollbackChild.ports = oldChild.ports;
+              rollbackChild.greenPorts = oldChild.greenPorts;
+            }
+          }
+        }
+      } else {
+        const rollbackChildIndex = rollbackBlocklet.children.findIndex((c) => c.meta.did === child.meta.did);
+        if (rollbackChildIndex !== -1) {
+          rollbackBlocklet.children[rollbackChildIndex] = child;
+        }
+      }
+    }
+
+    await states.blocklet.upgradeBlocklet({ ...rollbackBlocklet });
+    manager.configSynchronizer.throttledSyncAppConfig(rollbackBlocklet);
     await manager._updateDependents(did);
+    manager.emit(BlockletEvents.statusChange, { ...rollbackBlocklet, error: { message: err.message } });
 
     const actionName = action === INSTALL_ACTIONS.INSTALL_COMPONENT ? 'install' : 'upgrade';
     const notificationEvent =

package/lib/event/index.js

@@ -318,6 +318,7 @@ module.exports = ({
       description: `Blocklet Server is ${status} successfully`,
       entityType: 'node',
       status: 'success',
+      source: 'system',
     });
   };
 

package/lib/index.js

@@ -684,6 +684,7 @@ function ABTNode(options) {
       if (['deleteBlocklet', 'installBlocklet'].includes(params.action) || teamDid === options.nodeDid) {
         const result = await states.auditLog.create(params, instance);
         // 如果是 installBlocklet, 不需要提前返回， 要将 log 记录在 service 中
+        // 如果是 deleteBlocklet, 需要提前返回，因为 deleteBlocklet 会触发 blocklet 的删除，不需要再往 service 的auditLog 表中插入记录了
         if (params.action !== 'installBlocklet') {
           return result;
         }

package/lib/states/blocklet.js

@@ -2,7 +2,6 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
-const pick = require('lodash/pick');
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const cloneDeep = require('@abtnode/util/lib/deep-clone');
@@ -15,7 +14,6 @@ const {
   forEachBlocklet,
   forEachBlockletSync,
   forEachComponentV2,
-  forEachComponentV2Sync,
   getBlockletServices,
   hasStartEngine,
 } = require('@blocklet/meta/lib/util');
@@ -591,14 +589,13 @@ class BlockletState extends BaseState {
         return res;
       }
 
-      // update children status
-      forEachComponentV2Sync(doc, (component) => {
+      for (const component of doc.children || []) {
         if (component.meta.group === BlockletGroup.gateway) {
-          return;
+          continue;
         }
 
         if (shouldSkipComponent(component.meta.did, componentDids)) {
-          return;
+          continue;
         }
 
         component[isGreen ? 'greenStatus' : 'status'] = status;
@@ -616,11 +613,16 @@ class BlockletState extends BaseState {
         }
         component.operator = operator;
         component.inProgressStart = Date.now();
-      });
+      }
 
-      const isSetStatus = status === BlockletStatus.downloading || status === BlockletStatus.waiting;
-      const updateData = isSetStatus ? pick(doc, ['status', 'children']) : pick(doc, ['children']);
-      updateData.operator = operator;
+      const shouldSetStatus = status === BlockletStatus.downloading || status === BlockletStatus.waiting;
+      const updateData = {
+        children: doc.children,
+        operator,
+      };
+      if (shouldSetStatus) {
+        updateData.status = status;
+      }
 
       const res = await this.updateBlocklet(did, updateData);
       return res;

package/lib/states/notification.js

@@ -223,7 +223,7 @@ class NotificationState extends BaseState {
       });
       return result.length > 0 ? result.map((item) => item.did) : [did];
     } catch (error) {
-      logger.error('getUserDids error: ', error);
+      logger.warn('getUserDids error: ', error);
       return [did];
     }
   }
@@ -798,16 +798,18 @@ class NotificationState extends BaseState {
       },
     };
 
-    const receiverDids = await this.getUserDids(receiver);
+    const includeWhere = {};
+    if (receiver) {
+      const receiverDids = await this.getUserDids(receiver);
+      includeWhere.receiver = { [Op.in]: receiverDids };
+    }
 
     const include = [
       {
         model: this.notificationReceivers.model,
         as: 'receivers',
         attributes: [],
-        where: {
-          receiver: { [Op.in]: receiverDids },
-        },
+        where: includeWhere,
         required: false,
       },
     ];

package/lib/team/manager.js

@@ -243,9 +243,23 @@ class TeamManager extends EventEmitter {
         users = users.concat(roleUsers);
       }
       if (userDids.length > 0) {
-        const queryUsers = await Promise.all(
-          userDids.map((did) => userState.getUser(did, { includePassports: true, enableConnectedAccount: true }))
-        );
+        let queryUsers = [];
+        if (userDids.includes('*')) {
+          queryUsers = await userState.getUsersByDids({
+            dids: userDids,
+            query: {
+              approved: true,
+              selection,
+              includeConnectedAccounts,
+              includePassports: true,
+            },
+          });
+        } else {
+          // 使用 getUser 查询的目的是为了避免传入的 receiver 不在user表中而存在于 connected_account 表中
+          queryUsers = await Promise.all(
+            userDids.map((did) => userState.getUser(did, { includePassports: true, enableConnectedAccount: true }))
+          );
+        }
 
         const validUsers = queryUsers.filter((user, index) => {
           if (!user) {