@abtnode/core 1.17.5-beta-20251208-123021-e8c53f96 → 1.17.5-beta-20251211-104355-426d7eb6

package/lib/blocklet/manager/disk.js

@@ -905,6 +905,44 @@ class DiskBlockletManager extends BaseBlockletManager {
       this.emit(BlockletEvents.statusChange, doc1);
       const startedBlockletDids = [];
       const errorBlockletDids = [];
+      const parentBlockletId = blocklet.id;
+
+      // Helper function to update child status immediately and emit events
+      const updateChildStatusImmediately = async (componentDid, status) => {
+        if (!states.blockletChild || !parentBlockletId) {
+          return;
+        }
+
+        try {
+          await states.blockletChild.updateChildStatus(parentBlockletId, componentDid, status, false, {
+            operator,
+          });
+
+          // Get updated blocklet to emit events
+          const updatedBlocklet = await this.getBlocklet(did);
+          const componentsInfo = getComponentsInternalInfo(updatedBlocklet);
+
+          this.emit(BlockletInternalEvents.componentUpdated, {
+            appDid: blocklet.appDid,
+            components: componentsInfo.filter((c) => c.did === componentDid),
+          });
+
+          if (status === BlockletStatus.running) {
+            this.emit(BlockletInternalEvents.componentStarted, {
+              appDid: blocklet.appDid,
+              components: [{ did: componentDid }],
+            });
+          }
+
+          this.emit(BlockletEvents.statusChange, updatedBlocklet);
+        } catch (err) {
+          logger.error('Failed to update child status immediately', {
+            componentDid,
+            status,
+            error: err.message,
+          });
+        }
+      };
 
       const notStartedComponentDids = await this.startRequiredComponents({
         componentDids,
@@ -915,11 +953,13 @@ class DiskBlockletManager extends BaseBlockletManager {
         e2eMode,
         context,
         atomic,
-        onStarted: (subDid) => {
+        onStarted: async (subDid) => {
           startedBlockletDids.push({ did: subDid });
+          await updateChildStatusImmediately(subDid, BlockletStatus.running);
         },
-        onError: (subDid, error) => {
+        onError: async (subDid, error) => {
           errorBlockletDids.push({ did: subDid, error });
+          await updateChildStatusImmediately(subDid, BlockletStatus.error);
         },
       });
 
@@ -933,11 +973,13 @@ class DiskBlockletManager extends BaseBlockletManager {
               e2eMode,
               componentDids: [componentDid],
               operator,
-              onStarted: (subDid) => {
+              onStarted: async (subDid) => {
                 startedBlockletDids.push({ did: subDid });
+                await updateChildStatusImmediately(subDid, BlockletStatus.running);
               },
-              onError: (subDid, error) => {
+              onError: async (subDid, error) => {
                 errorBlockletDids.push({ did: subDid, error });
+                await updateChildStatusImmediately(subDid, BlockletStatus.error);
               },
             },
             context
@@ -950,15 +992,12 @@ class DiskBlockletManager extends BaseBlockletManager {
       let errorDescription = '';
       let resultBlocklet = nextBlocklet;
 
+      // Status updates are now done immediately in callbacks, so we only need to handle final events and cleanup
       if (startedBlockletDids.length) {
-        await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
-          componentDids: startedBlockletDids.map((x) => x.did),
-          operator,
-        });
-
         const finalBlocklet = await this.getBlocklet(did);
         resultBlocklet = finalBlocklet;
 
+        // Sync app config after all components started
         await this.configSynchronizer.throttledSyncAppConfig(finalBlocklet, { wait: 200 });
         const componentsInfo = getComponentsInternalInfo(finalBlocklet);
         this.emit(BlockletInternalEvents.componentUpdated, {
@@ -1009,10 +1048,7 @@ class DiskBlockletManager extends BaseBlockletManager {
           componentDids: errorBlockletDids.map((x) => x.did),
           shouldUpdateBlockletStatus: false,
         });
-        await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-          componentDids: errorBlockletDids.map((x) => x.did),
-          operator,
-        });
+
         const finalBlocklet = await this.getBlocklet(did);
         resultBlocklet = finalBlocklet;
         this.emit(BlockletEvents.startFailed, {

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

@@ -173,6 +173,97 @@ const blueGreenStartBlocklet = async (
 
   const startedBlockletDids = [];
   const errorBlockletDids = [];
+  const appId = blocklet1.id;
+
+  const notificationChange = async () => {
+    // Get latest children from blocklet_children table instead of reloading entire blocklet
+    const latestChildren = await states.blocklet.loadChildren(appId);
+
+    // Merge latest children into blocklet1 for event emission
+    const finalBlocklet = {
+      ...blocklet1,
+      children: latestChildren,
+    };
+
+    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 })),
+    });
+
+    // Emit statusChange event so UI can see the status change
+    manager.emit(BlockletEvents.statusChange, finalBlocklet);
+
+    manager.emit(BlockletEvents.started, { ...finalBlocklet, componentDids: startedBlockletDids.map((x) => x.did) });
+  };
+
+  // Helper function to update child status immediately and emit events
+  const updateChildStatusImmediately = async (componentDid, status, isGreen = false) => {
+    if (!states.blockletChild || !appId) {
+      return;
+    }
+
+    try {
+      const updates = {
+        operator,
+        inProgressStart: Date.now(),
+      };
+
+      if (status === BlockletStatus.running) {
+        updates.startedAt = new Date();
+        updates.stoppedAt = null;
+      } else if (status === BlockletStatus.error || status === BlockletStatus.stopped) {
+        updates.stoppedAt = new Date();
+      }
+
+      await states.blockletChild.updateChildStatus(appId, componentDid, status, isGreen, updates);
+
+      if (status === BlockletStatus.running) {
+        await states.blockletChild.updateChildStatus(appId, componentDid, BlockletStatus.stopped, !isGreen, updates);
+      }
+
+      // Get latest children from blocklet_children table and emit events immediately
+      const latestChildren = await states.blocklet.loadChildren(appId);
+      const updatedBlocklet = {
+        ...blocklet1,
+        children: latestChildren,
+      };
+      const componentsInfo = getComponentsInternalInfo(updatedBlocklet);
+
+      manager.emit(BlockletInternalEvents.componentUpdated, {
+        appDid: blocklet1.appDid,
+        components: componentsInfo.filter((c) => c.did === componentDid),
+      });
+
+      if (status === BlockletStatus.running) {
+        manager.emit(BlockletInternalEvents.componentStarted, {
+          appDid: blocklet1.appDid,
+          components: [{ did: componentDid }],
+        });
+      }
+
+      manager.emit(BlockletEvents.statusChange, updatedBlocklet);
+
+      // Emit statusChange event immediately so UI can see each component's status change
+      manager.emit(BlockletEvents.started, {
+        ...updatedBlocklet,
+        componentDids: startedBlockletDids.map((x) => x.did),
+      });
+    } catch (err) {
+      logger.error('Failed to update child status immediately', {
+        componentDid,
+        status,
+        isGreen,
+        error: err.message,
+      });
+    }
+  };
 
   for (const item of blueGreenComponentIds) {
     if (!item.componentDids.length) {
@@ -274,6 +365,11 @@ const blueGreenStartBlocklet = async (
           // 收集成功的组件（排除已经在 errorBlockletDids 中的组件）
           startedBlockletDids.push({ did: subDid, isGreen: item.changeToGreen });
 
+          // Update status immediately
+          await updateChildStatusImmediately(subDid, BlockletStatus.running, item.changeToGreen);
+
+          await manager.deleteProcess({ did, componentDids: [subDid], isGreen: !item.changeToGreen });
+
           logger.info('Green environment started successfully', {
             did,
             componentDids: [subDid],
@@ -285,6 +381,9 @@ const blueGreenStartBlocklet = async (
           // 收集失败的组件
           errorBlockletDids.push({ did: subDid, error, isGreen: item.changeToGreen });
 
+          // Update status immediately
+          await updateChildStatusImmediately(subDid, BlockletStatus.error, item.changeToGreen);
+
           try {
             await manager.deleteProcess({ did, componentDids: [subDid], isGreen: item.changeToGreen });
           } catch (cleanupError) {
@@ -326,37 +425,6 @@ const blueGreenStartBlocklet = async (
       });
     }
 
-    const greenBlockletDids = errorBlockletDids.filter((x) => x.isGreen).map((x) => x.did);
-    const blueBlockletDids = errorBlockletDids.filter((x) => !x.isGreen).map((x) => x.did);
-
-    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,
-      });
-    }
-
-    if (blueBlockletDids.length) {
-      await manager.deleteProcess({
-        did,
-        componentDids: blueBlockletDids,
-        shouldUpdateBlockletStatus: false,
-        isGreen: false,
-      });
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-        componentDids: blueBlockletDids,
-        operator,
-        isGreen: false,
-      });
-    }
-
     const finalBlocklet = await manager.getBlocklet(did);
     manager.emit(BlockletEvents.startFailed, {
       ...finalBlocklet,
@@ -368,45 +436,7 @@ const blueGreenStartBlocklet = async (
 
   // 处理成功启动的组件
   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 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),
-    });
+    await notificationChange();
   }
 
   // 根据情况更新 route table， 会判断只有包含多 interfaces 的 DID 才会更新 route table

package/lib/blocklet/migration-dist/migration.cjs

@@ -514,7 +514,7 @@ module.exports = Object.freeze({
   BLOCKLET_STORE: {
     id: 'zNKqX7D8ZAYa77HgzpoFfnV3BFbcmSRrE9aT',
     name: 'Official Store',
-    description: 'ArcBlock official blocklet registry',
+    description: 'ArcBlock official store for production ready blocklets',
     url: BLOCKLET_STORE_URL,
     logoUrl: '/logo.png',
     maintainer: 'arcblock',
@@ -522,11 +522,19 @@ module.exports = Object.freeze({
   BLOCKLET_STORE_DEV: {
     id: 'zNKmfUatDhzfMVACfr3u97eqndj8f1yXXw3m',
     name: 'Dev Store',
-    description: 'ArcBlock dev registry that contains demo and example blocklets',
+    description: 'ArcBlock official store for demo and example blocklets',
     url: BLOCKLET_STORE_URL_DEV,
     maintainer: 'arcblock',
     logoUrl: '/logo.png',
   },
+  BLOCKLET_TEST_STORE: {
+    id: 'zNKirQVRx4xbyTPMkvH3kguRfofTJana8WBK',
+    name: 'Test Store',
+    description: 'ArcBlock official store for non-production ready blocklets',
+    url: TEST_STORE_URL,
+    maintainer: 'arcblock',
+    logoUrl: '/logo.png',
+  },
 
   // application is a container, components have no hierarchy and are tiled in application
   APP_STRUCT_VERSION: '2',

package/lib/event/index.js

@@ -25,6 +25,7 @@ const { encode } = require('@abtnode/util/lib/base32');
 const dayjs = require('@abtnode/util/lib/dayjs');
 
 const { isInstanceWorker } = require('@abtnode/util/lib/pm2/is-instance-worker');
+const { isInServerlessMode } = require('@abtnode/util/lib/serverless');
 const { NodeMonitSender } = require('../monitor/node-monit-sender');
 const { isCLI } = require('../util');
 
@@ -44,6 +45,7 @@ const {
   routingSnapshotPrefix,
 } = require('./util');
 const { ensureBlockletHasMultipleInterfaces } = require('../router/helper');
+const { sendServerlessHeartbeat } = require('../util/launcher');
 
 /**
  *
@@ -80,6 +82,10 @@ module.exports = ({
   const events = new EventEmitter();
   events.setMaxListeners(0);
 
+  // Throttle serverless heartbeat: only call once every 30 seconds
+  let lastServerlessHeartbeatTime = 0;
+  const SERVERLESS_HEARTBEAT_THROTTLE_MS = 30000;
+
   let eventHandler = null;
   events.setEventHandler = (handler) => {
     if (typeof handler === 'function') {
@@ -521,6 +527,39 @@ module.exports = ({
     } else {
       onEvent(eventName, payload);
     }
+
+    if (
+      [
+        BlockletEvents.started,
+        BlockletEvents.removed,
+        BlockletEvents.statusChange,
+        BlockletEvents.installed,
+        BlockletEvents.componentInstalled,
+        BlockletEvents.componentRemoved,
+      ].includes(eventName)
+    ) {
+      const now = Date.now();
+      const remainingMs = SERVERLESS_HEARTBEAT_THROTTLE_MS - (now - lastServerlessHeartbeatTime);
+      if (remainingMs <= 0) {
+        lastServerlessHeartbeatTime = now;
+        node
+          .getNodeInfo()
+          .then((nodeInfo) => {
+            if (isInServerlessMode({ mode: nodeInfo.mode })) {
+              logger.info('send serverless heartbeat', { eventName });
+              sendServerlessHeartbeat();
+            }
+          })
+          .catch((error) => {
+            logger.error('Failed to get node info to send serverless heartbeat', { error, eventName });
+          });
+      } else {
+        logger.debug('serverless heartbeat throttled', {
+          eventName,
+          remainingMs,
+        });
+      }
+    }
   };
 
   const downloadAddedBlocklet = async () => {

package/lib/migrations/index.js

@@ -169,11 +169,11 @@ const runSchemaMigrations = async ({
 
   // migrate server schema
   dbPaths.server = getDbFilePath(path.join(dataDir, 'core/server.db'));
-  await doSchemaMigration(dbPaths.server, 'server');
+  await doSchemaMigration(dbPaths.server, 'server', true);
   printSuccess(`Server schema successfully migrated: ${dbPaths.server}`);
   // migrate service schema
   dbPaths.service = getDbFilePath(path.join(dataDir, 'services/service.db'));
-  await doSchemaMigration(dbPaths.service, 'service');
+  await doSchemaMigration(dbPaths.service, 'service', true);
   printSuccess(`Service schema successfully migrated: ${dbPaths.service}`);
 
   // migrate blocklet schema
@@ -183,7 +183,7 @@ const runSchemaMigrations = async ({
     if (env) {
       const filePath = getDbFilePath(path.join(env.value, 'blocklet.db'));
       dbPaths.blocklets.push(filePath);
-      await doSchemaMigration(filePath, 'blocklet');
+      await doSchemaMigration(filePath, 'blocklet', true);
       printSuccess(`Blocklet schema successfully migrated: ${blocklet.appPid}: ${filePath}`);
     } else {
       printInfo(`Skip migrate schema for blocklet: ${blocklet.appPid}`);
@@ -193,7 +193,7 @@ const runSchemaMigrations = async ({
   // migrate certificate manager schema
   for (let i = 0; i < MODULES.length; i++) {
     const filePath = getDbFilePath(path.join(dataDir, `modules/${MODULES[i]}/module.db`));
-    await doSchemaMigration(filePath, MODULES[i]);
+    await doSchemaMigration(filePath, MODULES[i], true);
     dbPaths.certificateManagers.push(filePath);
     printSuccess(`${MODULES[i]} schema successfully migrated: ${filePath}`);
   }

package/lib/monitor/blocklet-runtime-monitor.js

@@ -230,16 +230,14 @@ class BlockletRuntimeMonitor extends EventEmitter {
 
     insertThrottleMap.set(blockletDid, now);
 
-    return this.states.runtimeInsight.insert({ did: blockletDid, ...value }).catch((err) => {
+    return this.states.runtimeInsight.insert({ did: blockletDid, ...value }).catch((error) => {
+      const err = typeof error === 'string' ? error : error.message;
       if (err.includes('duplicate key value violates unique constraint ')) {
         console.error('RuntimeInsight insert error duplicate key value violates unique constraint');
         return;
       }
       if (err.name === 'SequelizeValidationError') {
-        console.error(
-          'RuntimeInsight validation error',
-          err.errors.map((e) => e.message)
-        );
+        console.error('RuntimeInsight validation error:', err);
       } else {
         console.error('RuntimeInsight insert error', err);
       }

package/lib/states/blocklet-child.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-underscore-dangle */
+const { BlockletStatus } = require('@blocklet/constant');
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').BlockletChildState>
+ */
+class BlockletChildState extends BaseState {
+  constructor(model, config = {}) {
+    super(model, config);
+  }
+
+  /**
+   * Get children by parent blocklet ID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<Array>} - Array of children
+   */
+  async getChildrenByParentId(parentBlockletId) {
+    if (!parentBlockletId) {
+      return [];
+    }
+    const children = await this.find({ parentBlockletId }, {}, { createdAt: 1 });
+    return children || [];
+  }
+
+  /**
+   * Delete children by parent blocklet ID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<number>} - Number of deleted children
+   */
+  deleteByParentId(parentBlockletId) {
+    if (!parentBlockletId) {
+      return 0;
+    }
+    return this.remove({ parentBlockletId });
+  }
+
+  /**
+   * Update child status by parent blocklet ID and child DID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @param {string} childDid - The child DID
+   * @param {number} status - The status to set
+   * @param {Object} additionalFields - Additional fields to update
+   * @param {boolean} isGreen - Whether the child is green
+   * @returns {Promise<Object>} - Updated child
+   */
+  async updateChildStatus(parentBlockletId, childDid, status, isGreen = false, additionalFields = {}) {
+    if (!parentBlockletId) {
+      return null;
+    }
+    const children = await this.getChildrenByParentId(parentBlockletId);
+    const child = children.find((c) => c.childDid === childDid);
+
+    if (!child) {
+      return null;
+    }
+
+    const updates = {
+      ...additionalFields,
+    };
+    if (isGreen) {
+      updates.greenStatus = status;
+    } else {
+      updates.status = status;
+    }
+
+    if (status === BlockletStatus.running) {
+      updates.startedAt = new Date();
+      updates.stoppedAt = null;
+    } else if (status === BlockletStatus.stopped) {
+      updates.startedAt = null;
+      updates.stoppedAt = new Date();
+    }
+
+    const [, [updated]] = await this.update({ id: child.id }, { $set: updates });
+    return updated;
+  }
+
+  /**
+   * Batch update children status
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @param {Array<string>} childDids - Array of child DIDs to update
+   * @param {number} status - The status to set
+   * @param {Object} additionalFields - Additional fields to update
+   * @returns {Promise<Array>} - Updated children
+   */
+  async batchUpdateChildrenStatus(parentBlockletId, childDids, status, additionalFields = {}) {
+    if (!parentBlockletId) {
+      return [];
+    }
+    const children = await this.getChildrenByParentId(parentBlockletId);
+    const updates = [];
+
+    for (const child of children) {
+      if (childDids.includes(child.childDid)) {
+        const childUpdates = {
+          status,
+          ...additionalFields,
+        };
+
+        if (status === BlockletStatus.running) {
+          childUpdates.startedAt = new Date();
+          childUpdates.stoppedAt = null;
+        } else if (status === BlockletStatus.stopped) {
+          childUpdates.startedAt = null;
+          childUpdates.stoppedAt = new Date();
+        }
+
+        // eslint-disable-next-line no-await-in-loop
+        await this.update({ id: child.id }, { $set: childUpdates });
+        updates.push({ ...child, ...childUpdates });
+      }
+    }
+
+    return updates;
+  }
+}
+
+module.exports = BlockletChildState;