@abtnode/core 1.16.52-beta-20251003-083412-fdfc4e36 → 1.16.52-beta-20251005-235515-42ad5caf

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

@@ -0,0 +1,292 @@
+/* eslint-disable no-await-in-loop */
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet-manager:blue-green');
+const { BlockletStatus, BlockletGroup, BlockletEvents } = require('@blocklet/constant');
+const {
+  hasRunnableComponent,
+  getDisplayName,
+  isExternalBlocklet,
+  forEachBlockletSync,
+  getComponentMissingConfigs,
+} = require('@blocklet/meta/lib/util');
+const { getBlockletEngine, hasStartEngine } = require('@blocklet/meta/lib/engine');
+const {
+  forEachBlocklet,
+  validateBlocklet,
+  validateBlockletChainInfo,
+  ensureAppPortsNotOccupied,
+  getHealthyCheckTimeout,
+  getHookArgs,
+  shouldSkipComponent,
+} = require('../../../util/blocklet');
+const { startBlockletProcess } = require('../../../util/blocklet');
+const hooks = require('../../hooks');
+const checkNeedRunDocker = require('../../../util/docker/check-need-run-docker');
+const { blueGreenGetComponentIds } = require('./blue-green-get-componentids');
+const { dockerExec } = require('../../../util/docker/docker-exec');
+const { isDockerOnlySingleInstance } = require('../../../util/docker/is-docker-only-single-instances');
+
+/**
+ * 绿（Green）环境：指一个并行的、与蓝环境几乎一模一样的环境，用来部署新的版本。新代码、新配置都会先部署到绿环境中。
+ *
+ * @param {Object} params - 启动参数
+ * @param {string} params.did - blocklet DID
+ * @param {Array<string>} params.componentDids - 组件 DID 列表
+ * @param {string} params.operator - 操作者
+ * @param {Object} context - 上下文信息
+ * @param {Object} manager - blocklet 管理器实例
+ * @param {Object} states - 状态管理器
+ * @returns {Promise<Object>} 返回启动后的 blocklet 对象
+ */
+const blueGreenStartBlocklet = async (
+  { did, componentDids, operator: _operator, ignoreErrorNotification },
+  context,
+  manager,
+  states
+) => {
+  const operator = _operator || context?.user?.did;
+  const throwOnError = true;
+  const checkHealthImmediately = true;
+  const e2eMode = false;
+
+  logger.info('start green blocklet (blue-green deployment)', {
+    did,
+    componentDids,
+    throwOnError,
+    checkHealthImmediately,
+    e2eMode,
+    operator,
+  });
+
+  // 获取并验证 blocklet
+  const blocklet1 = await manager.ensureBlocklet(did, { e2eMode });
+  did = blocklet1.meta.did; // eslint-disable-line no-param-reassign
+
+  // 验证组件需求和引擎
+  await validateBlocklet(blocklet1);
+  await validateBlockletChainInfo(blocklet1);
+
+  if (!hasRunnableComponent(blocklet1)) {
+    throw new Error('No runnable component found');
+  }
+
+  const customerDockerUseVolumeComponentIds = [];
+  const otherComponentIds = [];
+  await forEachBlockletSync(blocklet1, (b) => {
+    if (!componentDids.includes(b.meta.did)) {
+      return;
+    }
+    if (isDockerOnlySingleInstance(b.meta)) {
+      customerDockerUseVolumeComponentIds.push(b.meta.did);
+    } else {
+      otherComponentIds.push(b.meta.did);
+    }
+  });
+
+  if (customerDockerUseVolumeComponentIds.length) {
+    await manager.stop(
+      { did, componentDids: customerDockerUseVolumeComponentIds, updateStatus: false, operator },
+      context
+    );
+    await manager.start({ did, componentDids: customerDockerUseVolumeComponentIds, operator }, context);
+  }
+
+  // 分类组件 ID
+  const entryComponentIds = [];
+  const nonEntryComponentIds = [];
+  const componentDidsSet = new Set(otherComponentIds);
+
+  await forEachBlocklet(
+    blocklet1,
+    (b) => {
+      if (!componentDidsSet.has(b.meta.did)) {
+        return;
+      }
+
+      if (b.meta.group === BlockletGroup.gateway) {
+        nonEntryComponentIds.push(b.meta.did);
+        return;
+      }
+      const engine = getBlockletEngine(b.meta);
+      if (engine.interpreter === 'blocklet') {
+        nonEntryComponentIds.push(b.meta.did);
+        return;
+      }
+      if (!hasStartEngine(b.meta)) {
+        nonEntryComponentIds.push(b.meta.did);
+        return;
+      }
+      entryComponentIds.push(b.meta.did);
+    },
+    { parallel: true, concurrencyLimit: 4 }
+  );
+
+  if (nonEntryComponentIds.length) {
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
+      componentDids: nonEntryComponentIds,
+      operator,
+      isGreen: true,
+    });
+  }
+
+  if (!entryComponentIds.length) {
+    await manager.emit(BlockletEvents.started, {
+      ...blocklet1,
+      componentDids: nonEntryComponentIds,
+    });
+    return;
+  }
+
+  // check required config
+  try {
+    for (const component of blocklet1.children) {
+      if (!entryComponentIds.includes(component.meta.did)) {
+        continue;
+      }
+      if (!shouldSkipComponent(component.meta.did, entryComponentIds)) {
+        const missingProps = getComponentMissingConfigs(component, blocklet1);
+        if (missingProps.length) {
+          throw new Error(
+            `Missing required configuration to start ${component.meta.title}: ${missingProps.map((x) => x.key).join(',')}`
+          );
+        }
+      }
+    }
+  } catch (error) {
+    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',
+      });
+    }
+    return;
+  }
+
+  const blueGreenComponentIds = await blueGreenGetComponentIds(blocklet1, entryComponentIds);
+
+  // eslint-disable-next-line no-unreachable-loop
+  await Promise.all(
+    blueGreenComponentIds.map(async (item) => {
+      if (!item.componentDids.length) {
+        return;
+      }
+      const nextBlocklet = await ensureAppPortsNotOccupied({
+        blocklet: blocklet1,
+        componentDids: item.componentDids,
+        states,
+        manager,
+        isGreen: item.changeToGreen,
+      });
+      try {
+        const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, {
+          componentDids: item.componentDids,
+          operator,
+          isGreen: item.changeToGreen,
+        });
+        nextBlocklet.greenStatus = BlockletStatus.starting;
+        manager.emit(BlockletEvents.statusChange, doc1);
+
+        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: item.componentDids,
+          configSynchronizer: manager.configSynchronizer,
+          isGreen: item.changeToGreen,
+        });
+
+        // 健康检查绿色环境
+        const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(nextBlocklet, {
+          checkHealthImmediately,
+          componentDids: item.componentDids,
+        });
+
+        await manager._onCheckIfStarted(
+          {
+            did,
+            context,
+            minConsecutiveTime,
+            timeout: startTimeout,
+            componentDids: item.componentDids,
+          },
+          { throwOnError: true, isGreen: item.changeToGreen, needUpdateBlueStatus: true }
+        );
+
+        logger.info('Green environment started successfully', {
+          did,
+          componentDids: item.componentDids,
+        });
+      } 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 });
+          manager.emit(BlockletEvents.statusChange, blocklet1);
+        } catch (cleanupError) {
+          logger.error('Failed to cleanup green environment', { cleanupError });
+        }
+
+        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',
+          });
+        }
+
+        if (throwOnError) {
+          throw new Error(description);
+        }
+        throw error;
+      }
+    })
+  );
+};
+
+module.exports = {
+  blueGreenStartBlocklet,
+};

package/lib/blocklet/manager/helper/blue-green-update-blocklet-status.js

@@ -0,0 +1,18 @@
+const blueGreenUpdateBlockletStatus = async ({ states, did, status, blueGreenComponentIds }) => {
+  const outputBlocklet = {};
+  await Promise.all(
+    blueGreenComponentIds.map(async (item) => {
+      if (!item.componentDids.length) {
+        return;
+      }
+      const res = await states.blocklet.setBlockletStatus(did, status, {
+        componentDids: item.componentDids,
+        isGreen: item.changeToGreen,
+      });
+      Object.assign(outputBlocklet, res);
+    })
+  );
+  return outputBlocklet;
+};
+
+module.exports = { blueGreenUpdateBlockletStatus };

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

@@ -0,0 +1,191 @@
+/* eslint-disable no-await-in-loop */
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet-manager:upgrade-blue-green');
+const { BlockletStatus, BlockletEvents, BlockletInternalEvents } = require('@blocklet/constant');
+const { INSTALL_ACTIONS, WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
+const { getDisplayName, hasStartEngine } = require('@blocklet/meta/lib/util');
+const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
+const { getComponentNamesWithVersion, updateBlockletFallbackLogo } = require('../../../util/blocklet');
+const { blueGreenStartBlocklet } = require('./blue-green-start-blocklet');
+
+const blueGreenUpgradeBlocklet = async (
+  { newBlocklet, oldBlocklet, componentDids, action, shouldCleanUploadFile, url },
+  context,
+  manager,
+  states
+) => {
+  const { meta, source, deployedFrom, children } = newBlocklet;
+  const { did, version, name } = meta;
+  const title = getDisplayName(newBlocklet);
+
+  for (const child of newBlocklet.children) {
+    for (const child2 of oldBlocklet.children) {
+      if (child && child2 && child.meta.did === child2.meta.did) {
+        child.status = child2.status;
+        child.greenStatus = child2.greenStatus;
+        child.ports = child2.ports;
+        child.greenPorts = child2.greenPorts;
+      }
+    }
+  }
+
+  try {
+    await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
+    logger.info('updated blocklet for upgrading', { did, componentDids, source, name });
+
+    await manager._setConfigsFromMeta(did);
+
+    let blocklet = await manager.ensureBlocklet(did);
+
+    await manager._updateBlockletEnvironment(did);
+    blocklet = await manager.getBlocklet(did);
+
+    await manager._runUserHook('preInstall', blocklet, context);
+    await manager._runUserHook('postInstall', blocklet, context);
+    await manager._runUserHook('preFlight', blocklet, context);
+    await manager._runMigration({
+      parallel: false,
+      did,
+      blocklet,
+      oldBlocklet,
+      componentDids,
+    });
+
+    const runningDids = [];
+    const stoppedDids = [];
+
+    if (action === INSTALL_ACTIONS.INSTALL_COMPONENT) {
+      for (const componentDid of componentDids) {
+        const component = blocklet.children.find((x) => x.meta.did === componentDid);
+        if (!component) {
+          continue;
+        }
+        if (hasStartEngine(component.meta)) {
+          stoppedDids.push(componentDid);
+        } else {
+          runningDids.push(componentDid);
+        }
+      }
+    } else {
+      for (const componentDid of componentDids) {
+        const oldComponent = oldBlocklet.children.find((x) => x.meta.did === componentDid);
+        if (oldComponent?.status === BlockletStatus.running || oldComponent?.greenStatus === BlockletStatus.running) {
+          runningDids.push(componentDid);
+        } else {
+          stoppedDids.push(componentDid);
+        }
+      }
+    }
+
+    const initialized = !!blocklet.settings?.initialized;
+
+    if (runningDids.length) {
+      if (initialized) {
+        await blueGreenStartBlocklet(
+          { did, componentDids: runningDids, operator: context?.user?.did, ignoreErrorNotification: true },
+          context,
+          manager,
+          states
+        );
+        await states.blocklet.setInstalledAt(did);
+      } else {
+        await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+          componentDids: runningDids,
+          isGreenAndBlue: true,
+        });
+      }
+    }
+
+    if (stoppedDids.length) {
+      const status = action === INSTALL_ACTIONS.INSTALL_COMPONENT ? BlockletStatus.installed : BlockletStatus.stopped;
+      await states.blocklet.setBlockletStatus(did, status, {
+        componentDids: stoppedDids,
+        isGreenAndBlue: true,
+      });
+    }
+
+    blocklet = await manager.getBlocklet(did, context);
+
+    await updateBlockletFallbackLogo(blocklet);
+
+    await manager._updateDependents(did);
+
+    manager.refreshListCache();
+
+    manager.configSynchronizer.throttledSyncAppConfig(blocklet);
+
+    try {
+      manager.emit(BlockletEvents.upgraded, { blocklet, context });
+
+      const isInstallAction = action === INSTALL_ACTIONS.INSTALL_COMPONENT;
+      const notificationEvent = isInstallAction ? BlockletEvents.componentInstalled : BlockletEvents.componentUpgraded;
+      const actionName = isInstallAction ? 'installed' : 'upgraded';
+
+      manager.emit(notificationEvent, { ...blocklet, componentDids, oldBlocklet, context });
+
+      manager._createNotification(did, {
+        title: `Component ${actionName} succeed`,
+        description: `${getComponentNamesWithVersion(
+          newBlocklet,
+          componentDids
+        )} is ${actionName} successfully for ${title}`,
+        action: `/blocklets/${did}/overview`,
+        blockletDashboardAction: `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin/blocklets`,
+        entityType: 'blocklet',
+        entityId: did,
+        severity: 'success',
+      });
+
+      if (shouldCleanUploadFile && url) {
+        manager._cleanUploadFile(url);
+      }
+    } catch (error) {
+      logger.error('emit upgrade notification failed', { name, version, error });
+    }
+
+    await manager._ensureDeletedChildrenInSettings(blocklet);
+
+    if (oldBlocklet.status === BlockletStatus.running || oldBlocklet.greenStatus === BlockletStatus.running) {
+      manager.emit(
+        action === INSTALL_ACTIONS.INSTALL_COMPONENT
+          ? BlockletInternalEvents.componentInstalled
+          : BlockletInternalEvents.componentUpgraded,
+        {
+          appDid: blocklet.appDid,
+          components: getComponentsInternalInfo(blocklet).filter((c) => componentDids.includes(c.did)),
+        }
+      );
+    }
+
+    return blocklet;
+  } catch (err) {
+    logger.error('failed to upgrade blocklet', { did, version, name, error: err });
+    manager.configSynchronizer.throttledSyncAppConfig(oldBlocklet);
+    await manager._updateDependents(did);
+
+    const actionName = action === INSTALL_ACTIONS.INSTALL_COMPONENT ? 'install' : 'upgrade';
+    const notificationEvent =
+      action === INSTALL_ACTIONS.INSTALL_COMPONENT
+        ? BlockletEvents.componentInstallFailed
+        : BlockletEvents.componentUpgradeFailed;
+
+    manager.emit(notificationEvent, {
+      blocklet: { ...newBlocklet, componentDids, error: { message: err.message } },
+      context,
+    });
+
+    manager._createNotification(did, {
+      title: `Component ${actionName} failed`,
+      description: `${getComponentNamesWithVersion(newBlocklet, componentDids)} ${actionName} failed for ${title}: ${
+        err.message
+      }.`,
+      entityType: 'blocklet',
+      entityId: did,
+      severity: 'error',
+    });
+    throw err;
+  }
+};
+
+module.exports = {
+  blueGreenUpgradeBlocklet,
+};

package/lib/blocklet/manager/helper/upgrade-components.js

@@ -3,7 +3,7 @@ const cloneDeep = require('@abtnode/util/lib/deep-clone');
 
 const logger = require('@abtnode/logger')('@abtnode/core:upgrade-component');
 
-const { BlockletStatus, BlockletEvents } = require('@blocklet/constant');
+const { BlockletEvents } = require('@blocklet/constant');
 const { INSTALL_ACTIONS } = require('@abtnode/constant');
 const { parseOptionalComponents } = require('@blocklet/resolver');
 const {
@@ -127,17 +127,11 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
     children: children.map((x) => ({ name: x.meta.name, version: x.meta.version })),
   });
 
-  // new blocklet
-  const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting, { componentDids });
-
-  newBlocklet.children = children;
+  const newBlocklet = { ...oldBlocklet, children };
   await validateBlocklet(newBlocklet);
 
-  manager.emit(BlockletEvents.statusChange, newBlocklet);
-
   const action = INSTALL_ACTIONS.UPGRADE_COMPONENT;
 
-  // backup rollback data
   await manager._rollbackCache.backup({ did, action, oldBlocklet });
 
   // add to queue
@@ -158,7 +152,6 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
   ticket.on('failed', async (err) => {
     logger.error('queue failed', { entity: 'blocklet', action, did, error: err });
     await manager._rollback(action, did, oldBlocklet);
-
     manager.emit(BlockletEvents.componentUpgradeFailed, {
       blocklet: { ...oldBlocklet, componentDids, error: { message: err.message } },
       context: { ...context, createAuditLog: false },