@abtnode/core 1.17.8-beta-20260109-075740-5f484e08 → 1.17.8-beta-20260111-112953-aed5ff39

package/lib/blocklet/manager/disk/stop-restart-manager.js

@@ -0,0 +1,292 @@
+/* eslint-disable no-await-in-loop */
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:stop-restart');
+const {
+  BlockletEvents,
+  BlockletInternalEvents,
+  SUSPENDED_REASON,
+  BLOCKLET_CONTROLLER_STATUS,
+  BlockletStatus,
+} = require('@blocklet/constant');
+const { getDisplayName, isExternalBlocklet } = require('@blocklet/meta/lib/util');
+
+const states = require('../../../states');
+const launcher = require('../../../util/launcher');
+const hooks = require('../../hooks');
+const {
+  stopBlockletProcess,
+  reloadBlockletProcess,
+  getRuntimeEnvironments,
+  shouldSkipComponent,
+  getComponentNamesWithVersion,
+  getHookArgs,
+} = require('../../../util/blocklet');
+const checkNeedRunDocker = require('../../../util/docker/check-need-run-docker');
+const { dockerExec } = require('../../../util/docker/docker-exec');
+
+/**
+ * Stop blocklet
+ */
+async function stop(
+  manager,
+  { did, updateStatus = true, silent = false, componentDids, reason, operator: _operator },
+  context
+) {
+  const operator = _operator || context?.user?.did;
+  logger.info('stop blocklet', { did, componentDids, updateStatus, silent, operator });
+
+  const blocklet = await manager.getBlocklet(did);
+  const { processId } = blocklet.env;
+
+  if (updateStatus) {
+    const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, {
+      componentDids,
+      operator,
+      isGreenAndBlue: true,
+    });
+    blocklet.status = BlockletStatus.stopping;
+    manager.emit(BlockletEvents.statusChange, doc);
+  }
+
+  try {
+    const nodeInfo = await states.node.read();
+    const nodeEnvironments = await states.node.getEnvironments(nodeInfo);
+    await stopBlockletProcess(blocklet, {
+      preStop: async (b, { ancestors }) => {
+        const nextEnv = getRuntimeEnvironments(b, nodeEnvironments, ancestors);
+        const needRunDocker = await checkNeedRunDocker(b.meta, nextEnv, nodeInfo, isExternalBlocklet(blocklet));
+        const hookArgs = getHookArgs(b);
+        if (needRunDocker) {
+          const script = b.meta.scripts?.preStop;
+          if (script) {
+            return dockerExec({
+              blocklet,
+              meta: b.meta,
+              script,
+              env: nextEnv,
+              hookName: 'preStop',
+              nodeInfo,
+              ...hookArgs,
+            });
+          }
+          return null;
+        }
+        return hooks.preStop(b.meta.title, {
+          appDir: b.env.appDir,
+          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+          env: nextEnv,
+          did, // root blocklet did
+          notification: states.notification,
+          context,
+          exitOnError: false,
+          silent,
+          teamManager: manager.teamManager,
+          ...hookArgs,
+        });
+      },
+      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,
+        isGreenAndBlue: true,
+      });
+      manager.emit(BlockletEvents.statusChange, res);
+    }
+    throw error;
+  }
+
+  logger.info('blocklet stopped successfully', { processId, did });
+
+  launcher.notifyBlockletStopped(blocklet);
+
+  if (updateStatus) {
+    const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+      componentDids,
+      operator,
+      isGreenAndBlue: true,
+    });
+    // send notification to websocket channel
+    manager.emit(BlockletEvents.statusChange, res);
+
+    // send notification to wallet
+    manager.emit(BlockletEvents.stopped, { ...res, componentDids });
+
+    manager.emit(BlockletInternalEvents.componentStopped, {
+      appDid: blocklet.appDid,
+      components: componentDids?.length
+        ? componentDids.map((x) => ({ did: x }))
+        : blocklet.children.map((x) => ({ did: x.meta.did })),
+    });
+    manager.configSynchronizer.throttledSyncAppConfig(blocklet.meta.did);
+
+    let description = `${
+      componentDids?.length ? getComponentNamesWithVersion(blocklet, componentDids) : 'All components'
+    } is successfully stopped for ${getDisplayName(blocklet)}.`;
+
+    if (reason === SUSPENDED_REASON.expired) {
+      description = `${description} Reason: The subscription has expired.`;
+    }
+    const stopLength = componentDids?.length || 0;
+    manager._createNotification(did, {
+      title: `${stopLength > 1 ? `${stopLength} components` : 'Component'} stopped successfully for ${getDisplayName(blocklet)}`,
+      description,
+      entityType: 'blocklet',
+      entityId: did,
+      severity: 'success',
+    });
+
+    return res;
+  }
+
+  return blocklet;
+}
+
+/**
+ * Restart blocklet
+ */
+async function restart(manager, { did, componentDids, operator: _operator }, context) {
+  const operator = _operator || context?.user?.did;
+  logger.info('restart blocklet', { did, operator });
+  const blocklet = await manager.getBlocklet(did);
+  await manager.checkControllerStatus(blocklet, 'restart');
+
+  const result = await states.blocklet.getBlocklet(did);
+  const dids = componentDids?.length
+    ? componentDids
+    : result.children
+        .filter((x) => x.status === BlockletStatus.running || x.greenStatus === BlockletStatus.running)
+        .map((x) => x.meta.did);
+  manager.emit(BlockletEvents.statusChange, result);
+
+  const ticket = manager.startQueue.push({
+    entity: 'blocklet',
+    action: 'restart',
+    id: `${did}/${(dids || []).join(',')}`,
+    did,
+    componentDids: dids,
+    operator,
+    context,
+  });
+  ticket.on('failed', (err) => {
+    logger.error('failed to restart blocklet', { did, error: err });
+
+    const description = `${getComponentNamesWithVersion(result, componentDids)} restart failed for ${getDisplayName(
+      result
+    )}: ${err.message || 'queue exception'}`;
+    const upgradeLength = dids.length;
+    manager._createNotification(did, {
+      title: `${upgradeLength > 1 ? `${upgradeLength} components` : 'Component'} failed to restart for ${getDisplayName(result)}`,
+      description,
+      entityType: 'blocklet',
+      entityId: did,
+      severity: 'error',
+    });
+  });
+
+  return result;
+}
+
+/**
+ * Reload blocklet
+ */
+async function reload(manager, { did, componentDids: list }) {
+  const blocklet = await manager.getBlocklet(did);
+  await manager.checkControllerStatus(blocklet, 'reload');
+
+  const componentDids = (blocklet.children || [])
+    .filter((x) => x.status === BlockletStatus.running)
+    .filter((x) => !shouldSkipComponent(x.meta.did, list))
+    .map((x) => x.meta.did);
+
+  if (!componentDids.length) {
+    throw new Error('No running component found');
+  }
+
+  try {
+    await reloadBlockletProcess(blocklet, { componentDids });
+    const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.running, { componentDids });
+    logger.info('blocklet reload successfully', { did, componentDids });
+    manager.emit(BlockletEvents.statusChange, res);
+    return res;
+  } catch (error) {
+    logger.error('Failed to reload blocklet', { error, did, componentDids });
+    throw error;
+  }
+}
+
+/**
+ * Stop expired blocklets
+ */
+async function stopExpiredBlocklets(manager) {
+  try {
+    logger.info('start checking expired blocklet');
+    const blockletExtras = await states.blockletExtras.find(
+      {
+        controller: {
+          $exists: true,
+        },
+      },
+      { did: 1, meta: 1, controller: 1 }
+    );
+
+    if (blockletExtras.length === 0) {
+      logger.info('no serverless blocklet');
+      return;
+    }
+
+    logger.info('serverless blocklet count', { count: blockletExtras.length });
+
+    for (const data of blockletExtras) {
+      try {
+        const { did } = data;
+        const isExpired = await launcher.isBlockletExpired(did, data.controller);
+
+        if (isExpired) {
+          logger.info('the blocklet already expired and will be stopped', {
+            blockletDid: did,
+            nftId: data.controller.nftId,
+          });
+
+          // 如果 Blocklet 没停止, 先停止
+          const blocklet = await states.blocklet.getBlocklet(did);
+          if (blocklet.status !== BlockletStatus.stopped) {
+            await stop(manager, { did, reason: SUSPENDED_REASON.expired });
+            logger.info('the expired blocklet is stopped', { did, blockletDid: did });
+          }
+
+          await states.blockletExtras.updateByDid(did, {
+            controller: {
+              ...data.controller,
+              status: {
+                value: BLOCKLET_CONTROLLER_STATUS.suspended,
+                reason: SUSPENDED_REASON.expired,
+              },
+            },
+          });
+          logger.info('the expired blocklet is stopped', { did });
+        }
+      } catch (error) {
+        logger.error('stop expired blocklet failed', {
+          blockletDid: data.did,
+          nftId: data.controller?.nftId,
+          error,
+        });
+      }
+    }
+
+    logger.info('check expired external blocklet end');
+  } catch (error) {
+    logger.error('check expired external blocklet failed', { error });
+  }
+}
+
+module.exports = {
+  stop,
+  restart,
+  reload,
+  stopExpiredBlocklets,
+};

package/lib/blocklet/manager/disk/update-manager.js

@@ -0,0 +1,153 @@
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:update');
+const md5 = require('@abtnode/util/lib/md5');
+const { WELLKNOWN_SERVICE_PATH_PREFIX } = require('@abtnode/constant');
+const { BlockletStatus } = require('@blocklet/constant');
+const { getBlockletInfo } = require('@blocklet/meta/lib/info');
+const { getDisplayName } = require('@blocklet/meta/lib/util');
+
+const states = require('../../../states');
+const launcher = require('../../../util/launcher');
+const { shouldJobBackoff } = require('../../../util');
+const UpgradeComponents = require('../helper/upgrade-components');
+
+/**
+ * Check for component updates
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Blocklet DID
+ * @returns {Promise<void>}
+ */
+async function _onCheckForComponentUpdate(manager, { did }) {
+  if (shouldJobBackoff()) {
+    logger.warn('Check for component update is not available when blocklet server is starting.');
+    return;
+  }
+
+  const blocklet = await manager.getBlocklet(did);
+  if (blocklet.status === BlockletStatus.stopped) {
+    logger.warn('Check for component update is not available when blocklet is stopped.');
+    return;
+  }
+
+  const list = await UpgradeComponents.check({ did, states });
+  if (!list || !list.updateList?.length) {
+    return;
+  }
+  const componentDids = list.updateList.map((item) => item.meta.did);
+  const updateList = list.updateList.map((item) => {
+    return { title: item.meta.title, description: item.meta.description, version: item.meta.version };
+  });
+
+  const checkUpdateMd5 = md5(JSON.stringify(updateList));
+  const oldMd5 = await states.blockletExtras.getSettings(did, 'checkUpdateMd5', '');
+  // notification has been sent, no more
+  if (checkUpdateMd5 === oldMd5) {
+    return;
+  }
+
+  const firstComponent = updateList[0];
+  const blockletTitle = getDisplayName(blocklet);
+
+  const description = {
+    en: `${blockletTitle} has components with a new version: ${firstComponent.title} ${firstComponent.version} ${
+      updateList.length > 1 ? 'and more...' : '.'
+    }`,
+    zh: `${blockletTitle} 的组件有新版本: ${firstComponent.title} ${updateList.length > 1 ? '等等...' : '.'}`,
+  };
+  const title = {
+    en: `${blockletTitle} has components with a new version`,
+    zh: `${blockletTitle} 的组件有新版本`,
+  };
+  const body = {
+    en: `${blockletTitle} has new versions of the following components:`,
+    zh: `${blockletTitle} 以下组件有新版:`,
+  };
+  const button = {
+    en: 'Upgrade to new version',
+    zh: '升级到新版本',
+  };
+
+  const action = `/blocklets/${did}/components?checkUpdate=1`;
+  const blockletDashboardAction = `${WELLKNOWN_SERVICE_PATH_PREFIX}/admin/components?checkUpdate=1`;
+  const users = await manager.teamManager.getOwnerAndAdminUsers(did, true);
+  const nodeInfo = await states.node.read();
+  const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+
+  const attachments = [
+    {
+      type: 'section',
+      fields: updateList
+        .slice(0, 3)
+        .map((item) => {
+          return [
+            {
+              type: 'text',
+              data: { type: 'plain', color: '#9397A1', text: item.title },
+            },
+            {
+              type: 'text',
+              data: { type: 'plain', text: item.version },
+            },
+          ];
+        })
+        .flat(),
+    },
+  ];
+
+  try {
+    await manager._sendAllMessageToUser({
+      did,
+      blocklet,
+      title,
+      body,
+      button,
+      attachments,
+      description,
+      action,
+      blockletDashboardAction,
+      sender: {
+        appDid: wallet.address,
+        appSk: wallet.secretKey,
+      },
+      users,
+      componentDids,
+    });
+    await states.blockletExtras.setSettings(did, { checkUpdateMd5 });
+  } catch (err) {
+    logger.error('send checked update email failed', { error: err });
+  }
+}
+
+/**
+ * Report component usage
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Blocklet DID
+ * @param {Array<string>} params.componentDids - Component DIDs
+ * @param {string} params.eventType - Event type
+ * @param {string} params.time - Time
+ * @returns {Promise<void>}
+ */
+async function _reportComponentUsage(manager, { did, componentDids, eventType, time }) {
+  try {
+    logger.info('start report component usage', { did, componentDids, eventType });
+
+    const blocklet = await manager.getBlocklet(did);
+    await launcher.reportComponentsEvent({
+      blocklet,
+      dids: componentDids,
+      type: eventType,
+      time: time || new Date().toISOString(),
+    });
+
+    logger.info('report component usage success', { did, componentDids, eventType });
+  } catch (error) {
+    logger.error('report component usage failed', { did, componentDids, eventType, error });
+    throw error; // 一定要 throw 出去，否则会导致队列任务不会重试
+  }
+}
+
+module.exports = {
+  _onCheckForComponentUpdate,
+  _reportComponentUsage,
+};