@abtnode/core 1.8.65-beta-5405baf2 → 1.8.65-beta-bfcc12ce

package/lib/blocklet/manager/disk.js

@@ -129,6 +129,7 @@ const { SpacesRestore } = require('../storage/restore/spaces');
 const installFromBackup = require('./helper/install-from-backup');
 const { resolveDownload, resolveDiffDownload } = require('../downloader/resolve-download');
 const BlockletDownloader = require('../downloader/blocklet-downloader');
+const RollbackCache = require('./helper/rollback-cache');
 
 const {
   isInProgress,
@@ -218,6 +219,8 @@ class BlockletManager extends BaseBlockletManager {
       cache: states.cache,
     });
 
+    this._rollbackCache = new RollbackCache({ dir: this.dataDirs.tmp });
+
     if (daemon) {
       blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid));
       blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid));
@@ -255,6 +258,10 @@ class BlockletManager extends BaseBlockletManager {
   async install(params, context = {}) {
     logger.debug('install blocklet', { params, context });
 
+    if (!params.controller && context?.user?.controller) {
+      params.controller = context.user.controller;
+    }
+
     const info = await states.node.read();
 
     context.headers = Object.assign(context?.headers || {}, {
@@ -444,6 +451,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false }, context) {
     logger.info('start blocklet', { did });
+    // should check blocklet integrity
     const blocklet = await this.ensureBlocklet(did, { e2eMode });
 
     try {
@@ -557,7 +565,7 @@ class BlockletManager extends BaseBlockletManager {
   async stop({ did, updateStatus = true, silent = false }, context) {
     logger.info('stop blocklet', { did });
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
     const { processId } = blocklet.env;
 
     if (updateStatus) {
@@ -655,7 +663,7 @@ class BlockletManager extends BaseBlockletManager {
 
   // eslint-disable-next-line no-unused-vars
   async reload({ did }, context) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
     await reloadBlockletProcess(blocklet);
@@ -671,13 +679,12 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('delete blocklet', { did, keepData });
 
     try {
-      const blocklet = await this.ensureBlocklet(did, { validateEnv: false });
+      const blocklet = await this.getBlocklet(did);
       if (isDeletableBlocklet(blocklet) === false) {
         throw new Error('Blocklet is protected from accidental deletion');
       }
 
       const nodeEnvironments = await states.node.getEnvironments();
-
       await deleteBlockletProcess(blocklet, {
         preDelete: (b, { ancestors }) =>
           hooks.preUninstall(b.env.processId, {
@@ -700,31 +707,27 @@ class BlockletManager extends BaseBlockletManager {
         severity: 'success',
       });
       return doc;
-    } catch (err) {
+    } catch (error) {
       // If we installed a corrupted blocklet accidentally, just cleanup the disk and state db
-      if (err.code === 'BLOCKLET_CORRUPTED') {
-        logger.info('blocklet is corrupted, will delete again', { did });
-        const doc = await this._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
-
-        this._createNotification(doc.meta.did, {
-          title: 'Blocklet Deleted',
-          description: `Blocklet ${doc.meta.name}@${doc.meta.version} is deleted.`,
-          entityType: 'blocklet',
-          entityId: doc.meta.did,
-          severity: 'success',
-        });
+      logger.error('blocklet delete failed, will delete again', { did, error });
+      const doc = await this._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
 
-        return doc;
-      }
+      this._createNotification(doc.meta.did, {
+        title: 'Blocklet Deleted',
+        description: `Blocklet ${doc.meta.name}@${doc.meta.version} is deleted.`,
+        entityType: 'blocklet',
+        entityId: doc.meta.did,
+        severity: 'success',
+      });
 
-      throw err;
+      return doc;
     }
   }
 
   async reset({ did, childDid }, context = {}) {
     logger.info('reset blocklet', { did, childDid });
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     if (isInProgress(blocklet.status || blocklet.status === BlockletStatus.running)) {
       throw new Error('Cannot reset when blocklet is in progress');
@@ -774,7 +777,7 @@ class BlockletManager extends BaseBlockletManager {
   async deleteComponent({ did, rootDid, keepData, keepState }, context) {
     logger.info('delete blocklet component', { did, rootDid, keepData });
 
-    const blocklet = await this.ensureBlocklet(rootDid, { validateEnv: false });
+    const blocklet = await this.getBlocklet(rootDid);
     const child = blocklet.children.find((x) => x.meta.did === did);
     if (!child) {
       throw new Error('Component does not exist');
@@ -828,7 +831,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
     }
 
-    const newBlocklet = await this.ensureBlocklet(rootDid);
+    const newBlocklet = await this.getBlocklet(rootDid);
     this.emit(BlockletEvents.upgraded, { blocklet: newBlocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
 
     this._createNotification(newBlocklet.meta.did, {
@@ -843,12 +846,13 @@ class BlockletManager extends BaseBlockletManager {
     return newBlocklet;
   }
 
+  // eslint-disable-next-line no-unused-vars
   async cancelDownload({ did: inputDid }, context) {
     try {
       await statusLock.acquire();
       const blocklet = await states.blocklet.getBlocklet(inputDid);
       if (!blocklet) {
-        throw new Error('Can not cancel download for non-exist blocklet in database.', { inputDid });
+        throw new Error(`Can not cancel download for non-exist blocklet in database. did: ${inputDid}`);
       }
 
       const { name, did, version } = blocklet.meta;
@@ -858,15 +862,35 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       const job = await this.installQueue.get(did);
-      if (job) {
-        const { postAction, oldBlocklet } = job;
-        await this._rollback(postAction, did, oldBlocklet);
-      }
 
+      // cancel job
       if (blocklet.status === BlockletStatus.downloading) {
-        await this.blockletDownloader.cancelDownload(blocklet.meta.did);
+        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) {
-        await this._cancelWaiting(blocklet.meta, context);
+        try {
+          await this.installQueue.cancel(blocklet.meta.did);
+        } catch (error) {
+          logger.error('failed to cancel waiting', { did: blocklet.meta.did, error });
+        }
+      }
+
+      // rollback
+      if (job) {
+        const { postAction, oldBlocklet } = job;
+        await this._rollback(postAction, did, oldBlocklet);
+      } else {
+        const data = await this._rollbackCache.restore({ did });
+        if (data) {
+          const { action, oldBlocklet } = data;
+          await this._rollback(action, did, oldBlocklet);
+          await this._rollbackCache.remove({ did });
+        } else {
+          throw new Error(`Cannot find rollback data in queue or backup file of blocklet ${inputDid}`);
+        }
       }
 
       logger.info('cancel download blocklet', { did, name, version, status: fromBlockletStatus(blocklet.status) });
@@ -874,14 +898,25 @@ class BlockletManager extends BaseBlockletManager {
       statusLock.release();
       return blocklet;
     } catch (error) {
-      statusLock.release();
+      try {
+        // fallback blocklet status to error
+        const blocklet = await states.blocklet.getBlocklet(inputDid);
+        if (blocklet) {
+          await states.blocklet.setBlockletStatus(blocklet.meta.did, BlockletStatus.error);
+        }
+        statusLock.release();
+      } catch (err) {
+        statusLock.release();
+        logger.error('Failed to fallback blocklet status to error on cancelDownload', { error });
+      }
+
       throw error;
     }
   }
 
   // eslint-disable-next-line no-unused-vars
   async deleteProcess({ did }, context) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     logger.info('delete blocklet process', { did });
 
@@ -904,17 +939,17 @@ class BlockletManager extends BaseBlockletManager {
 
     if (!attachRuntimeInfo) {
       try {
-        const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
+        const blocklet = await this.getBlocklet(did, { throwOnNotExist: false });
         return blocklet;
       } catch (e) {
         logger.error('get blocklet detail error', { error: e });
-        return null; // TODO: 直接返回没有 runtime info 的数据
+        return states.blocklet.getBlocklet(did);
       }
     }
 
     const nodeInfo = await states.node.read();
 
-    return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
+    return this._attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
   async attachBlockletListRuntimeInfo({ blocklets, useCache }, context) {
@@ -929,7 +964,7 @@ class BlockletManager extends BaseBlockletManager {
           const cachedBlocklet =
             useCache && this.cachedBlocklets ? this.cachedBlocklets.find((y) => y.meta.did === x.meta.did) : null;
 
-          return this.attachRuntimeInfo({
+          return this._attachRuntimeInfo({
             did: x.meta.did,
             nodeInfo,
             diskInfo: false,
@@ -977,7 +1012,7 @@ class BlockletManager extends BaseBlockletManager {
     const [rootDid, ...childDids] = dids;
     logger.info('config blocklet', { dids });
 
-    let blocklet = await this.ensureBlocklet(rootDid);
+    let blocklet = await this.getBlocklet(rootDid);
     for (const childDid of childDids) {
       blocklet = blocklet.children.find((x) => x.meta.did === childDid);
       if (!blocklet) {
@@ -1035,20 +1070,20 @@ class BlockletManager extends BaseBlockletManager {
     await this.updateBlockletEnvironment(rootDid);
 
     // response
-    const newState = await this.ensureBlocklet(rootDid);
+    const newState = await this.getBlocklet(rootDid);
     this.emit(BlockletEvents.updated, newState);
     return newState;
   }
 
   async configPublicToStore({ did, publicToStore = false }) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
     // publicToStore 由用户传入
     // handleInstanceInStore 方法写在前面，保证向 store 操作成功后才会更改 blocklet 中的 publicToStore值
     // handleInstanceInStore 中会校验修改 publicToStore字段 的条件，不符合则会抛错，就不会执行下面更新 publicToStore 的逻辑
     await handleInstanceInStore(blocklet, { publicToStore });
     await states.blockletExtras.setSettings(did, { publicToStore });
 
-    const newState = await this.ensureBlocklet(did);
+    const newState = await this.getBlocklet(did);
     return newState;
   }
 
@@ -1058,7 +1093,7 @@ class BlockletManager extends BaseBlockletManager {
     }
     await states.blockletExtras.setSettings(did, { navigations });
 
-    const newState = await this.ensureBlocklet(did);
+    const newState = await this.getBlocklet(did);
     this.emit(BlockletEvents.updated, newState);
     return newState;
   }
@@ -1110,7 +1145,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blockletExtras.setConfigs(dids, configs);
     }
 
-    const blocklet = await this.ensureBlocklet(rootDid);
+    const blocklet = await this.getBlocklet(rootDid);
 
     this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
 
@@ -1158,7 +1193,7 @@ class BlockletManager extends BaseBlockletManager {
     // trigger dashboard frontend refresh
     this.emit(BlockletEvents.updated, blocklet);
 
-    return this.ensureBlocklet(rootDid);
+    return this.getBlocklet(rootDid);
   }
 
   async updateComponentMountPoint({ did, rootDid: inputRootDid, mountPoint }, context) {
@@ -1194,7 +1229,7 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.upgraded, { blocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
 
-    return this.ensureBlocklet(rootDid);
+    return this.getBlocklet(rootDid);
   }
 
   /**
@@ -1429,6 +1464,9 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.statusChange, newBlocklet);
 
+    // backup rollback data
+    await this._rollbackCache.backup({ did, action, oldBlocklet });
+
     // add to queue
     const ticket = this.installQueue.push(
       {
@@ -1540,6 +1578,8 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add Config
     await this._setConfigsFromMeta(did);
+
+    // should ensure blocklet integrity
     let blocklet = await this.ensureBlocklet(did);
 
     // pre install
@@ -1547,14 +1587,14 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add environments
     await this.updateBlockletEnvironment(did);
-    blocklet = await this.ensureBlocklet(did);
+    blocklet = await this.getBlocklet(did);
 
     // post install
     await this._runPostInstallHook(blocklet);
 
     await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
-    blocklet = await this.ensureBlocklet(did);
+    blocklet = await this.getBlocklet(did);
 
     await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
@@ -1607,6 +1647,8 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add Config
     await this._setConfigsFromMeta(rootDid);
+
+    // should ensure blocklet integrity
     let blocklet = await this.ensureBlocklet(rootDid);
 
     // pre install
@@ -1614,14 +1656,14 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add environments
     await this.updateBlockletEnvironment(rootDid);
-    blocklet = await this.ensureBlocklet(rootDid);
+    blocklet = await this.getBlocklet(rootDid);
 
     // post install
     await this._runPostInstallHook(blocklet);
 
     logger.info('add blocklet component for dev', { did, version, meta });
 
-    blocklet = await this.ensureBlocklet(rootDid);
+    blocklet = await this.getBlocklet(rootDid);
 
     return blocklet;
   }
@@ -1645,7 +1687,11 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async ensureBlocklet(did, opts = {}) {
-    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did });
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: true });
+  }
+
+  async getBlocklet(did, opts = {}) {
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
   }
 
   async hasBlocklet({ did }) {
@@ -1663,7 +1709,7 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
 
-    return this.ensureBlocklet(did);
+    return this.getBlocklet(did);
   }
 
   async status(did, { forceSync = false } = {}) {
@@ -1680,7 +1726,7 @@ class BlockletManager extends BaseBlockletManager {
       return res;
     };
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     let shouldUpdateStatus = forceSync || shouldUpdateBlockletStatus(blocklet.status);
     if (isInProgress(blocklet.status)) {
@@ -1709,80 +1755,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
-    if (!did) {
-      throw new Error('did should not be empty');
-    }
-
-    try {
-      const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
-
-      if (!blocklet) {
-        return null;
-      }
-
-      const fromCache = !!cachedBlocklet;
-
-      // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
-      if (fromCache) {
-        const cached = {};
-        forEachBlockletSync(cachedBlocklet, (component, { id }) => {
-          cached[id] = component;
-        });
-
-        Object.assign(blocklet, pick(cachedBlocklet, ['appRuntimeInfo', 'diskInfo']));
-
-        forEachBlockletSync(blocklet, (component, { id }) => {
-          if (cached[id]) {
-            Object.assign(component, pick(cached[id], ['runtimeInfo']));
-          }
-        });
-      }
-
-      // 处理 domainAliases#value SLOT_FOR_IP_DNS_SITE
-      if (blocklet?.site?.domainAliases?.length) {
-        const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
-        blocklet.site.domainAliases = blocklet.site.domainAliases.map((x) => ({
-          ...x,
-          value: util.replaceDomainSlot({ domain: x.value, context, nodeIp }),
-        }));
-      }
-
-      // app runtime info, app status
-      blocklet.appRuntimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did);
-
-      if (!fromCache) {
-        // app disk info, component runtime info, component status, component engine
-        await forEachBlocklet(blocklet, async (component, { level }) => {
-          component.engine = getEngine(getBlockletEngineNameByPlatform(component.meta)).describe();
-
-          if (level === 0) {
-            component.diskInfo = await getDiskInfo(component, {
-              useFakeDiskInfo: !diskInfo,
-            });
-          }
-
-          component.runtimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did, component.env.id);
-
-          if (component.runtimeInfo?.status && shouldUpdateBlockletStatus(component.status)) {
-            component.status = statusMap[component.runtimeInfo.status];
-          }
-        });
-      }
-
-      return blocklet;
-    } catch (err) {
-      const simpleState = await states.blocklet.getBlocklet(did);
-      logger.error('failed to get blocklet info', {
-        did,
-        name: get(simpleState, 'meta.name'),
-        status: get(simpleState, 'status'),
-        error: err,
-      });
-      return simpleState;
-    }
-  }
-
   async refreshListCache() {
     this.list({ useCache: false }).catch((err) => {
       logger.error('refresh blocklet list failed', { error: err });
@@ -1792,7 +1764,7 @@ class BlockletManager extends BaseBlockletManager {
   async onJob(job) {
     if (job.entity === 'blocklet') {
       if (job.action === 'download') {
-        await this.onDownload(job);
+        await this.downloadAndInstall(job);
       }
       if (job.action === 'restart') {
         await this.onRestart(job);
@@ -1817,33 +1789,35 @@ class BlockletManager extends BaseBlockletManager {
    * @return {*}
    * @memberof BlockletManager
    */
-  async onDownload(params) {
-    const { blocklet, context, postAction, oldBlocklet, throwOnError } = params;
+  async downloadAndInstall(params) {
+    const { blocklet, context, postAction, oldBlocklet, throwOnError, skipCheckStatusBeforeDownload } = params;
     const { meta } = blocklet;
     const { name, did, version } = meta;
 
     // check status
-    try {
-      await statusLock.acquire();
-
-      const b0 = await states.blocklet.getBlocklet(did);
-      if (!b0 || ![BlockletStatus.waiting].includes(b0.status)) {
-        if (!b0) {
-          throw new Error('blocklet does not exist before downloading');
-        } else {
-          throw new Error(`blocklet status is invalid before downloading: ${fromBlockletStatus(b0.status)}`);
+    if (!skipCheckStatusBeforeDownload) {
+      try {
+        await statusLock.acquire();
+
+        const b0 = await states.blocklet.getBlocklet(did);
+        if (!b0 || ![BlockletStatus.waiting].includes(b0.status)) {
+          if (!b0) {
+            throw new Error('blocklet does not exist before downloading');
+          } else {
+            throw new Error(`blocklet status is invalid before downloading: ${fromBlockletStatus(b0.status)}`);
+          }
         }
+        statusLock.release();
+      } catch (error) {
+        statusLock.release();
+        logger.error('Check blocklet status failed before downloading', {
+          name,
+          did,
+          error,
+        });
+        await this._rollback(postAction, did, oldBlocklet);
+        return;
       }
-      statusLock.release();
-    } catch (error) {
-      statusLock.release();
-      logger.error('Check blocklet status failed before downloading', {
-        name,
-        did,
-        error,
-      });
-      await this._rollback(postAction, did, oldBlocklet);
-      return;
     }
 
     // download bundle
@@ -1853,8 +1827,16 @@ class BlockletManager extends BaseBlockletManager {
       if (isCancelled) {
         logger.info('Download was canceled', { name, did, version });
 
-        if ((await states.blocklet.getBlockletStatus(did)) === BlockletStatus.downloading) {
-          await this._rollback(postAction, did, oldBlocklet);
+        // rollback on download cancelled
+        await statusLock.acquire();
+        try {
+          if ((await states.blocklet.getBlockletStatus(did)) === BlockletStatus.downloading) {
+            await this._rollback(postAction, did, oldBlocklet);
+          }
+          statusLock.release();
+        } catch (error) {
+          statusLock.release();
+          logger.error('Rollback blocklet failed on download canceled', { postAction, name, did, version, error });
         }
         return;
       }
@@ -1875,10 +1857,16 @@ class BlockletManager extends BaseBlockletManager {
         severity: 'error',
       });
 
+      // rollback on download failed
+      await statusLock.acquire();
       try {
-        await this._rollback(postAction, did, oldBlocklet);
-      } catch (e) {
-        logger.error('Rollback blocklet failed', { postAction, name, did, version });
+        if ((await states.blocklet.getBlockletStatus(did)) === BlockletStatus.downloading) {
+          await this._rollback(postAction, did, oldBlocklet);
+        }
+        statusLock.release();
+      } catch (error) {
+        statusLock.release();
+        logger.error('Rollback blocklet failed on download failed', { postAction, name, did, version, error });
       }
 
       if (throwOnError) {
@@ -1981,7 +1969,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async onCheckIfStarted(jobInfo, { throwOnError } = {}) {
     const { did, context, minConsecutiveTime = 5000, timeout } = jobInfo;
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     const { meta } = blocklet;
     const { name } = meta;
@@ -2022,7 +2010,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async updateBlockletEnvironment(did) {
-    const blockletWithEnv = await this.ensureBlocklet(did);
+    const blockletWithEnv = await this.getBlocklet(did);
     const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
 
@@ -2406,13 +2394,20 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
       newBlocklet.children = await this._getChildrenForInstallation(meta);
       await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet);
 
-      return this._upgradeBlocklet({
+      // backup rollback data
+      const action = 'upgrade';
+      await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
+
+      await this.downloadAndInstall({
+        blocklet: newBlocklet,
         oldBlocklet,
-        newBlocklet,
         context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
+        throwOnError: true,
+        postAction: action,
+        skipCheckStatusBeforeDownload: true,
       });
+      return this.getBlocklet(newBlocklet.meta.did);
     }
 
     // full deploy
@@ -2432,14 +2427,20 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
       newBlocklet.children = await this._getChildrenForInstallation(meta);
 
-      await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet);
+      // backup rollback data
+      const action = 'upgrade';
+      await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
 
-      return this._upgradeBlocklet({
+      await validateBlocklet(newBlocklet);
+      await this.downloadAndInstall({
+        blocklet: newBlocklet,
         oldBlocklet,
-        newBlocklet,
         context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
+        throwOnError: true,
+        postAction: action,
+        skipCheckStatusBeforeDownload: true,
       });
+      return this.getBlocklet(newBlocklet.meta.did);
     }
 
     // full deploy - install
@@ -2453,25 +2454,31 @@ class BlockletManager extends BaseBlockletManager {
       children,
     });
 
+    const action = 'install';
+    const oldState = { extraState: oldExtraState };
     try {
       await this._setConfigsFromMeta(meta.did);
       await validateBlocklet(blocklet);
 
       // check duplicate appSk
       await checkDuplicateAppSk({ did: meta.did, states });
-
-      // download
-      await this._downloadBlocklet(blocklet);
-
-      return this._installBlocklet({
-        did: meta.did,
-        context,
-        oldBlocklet: { extraState: oldExtraState },
-      });
     } catch (error) {
-      await this._rollback('install', meta.did, { extraState: oldExtraState });
+      await this._rollback(action, meta.did, oldState);
       throw error;
     }
+
+    // backup rollback data
+    await this._rollbackCache.backup({ did: meta.did, action, oldBlocklet: oldState });
+
+    await this.downloadAndInstall({
+      blocklet,
+      oldBlocklet: oldState,
+      context,
+      throwOnError: true,
+      postAction: action,
+      skipCheckStatusBeforeDownload: true,
+    });
+    return this.getBlocklet(meta.did);
   }
 
   async _installComponentFromUpload({
@@ -2552,34 +2559,19 @@ class BlockletManager extends BaseBlockletManager {
 
     await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild, { skipNavigation });
 
-    await this._downloadBlocklet(newBlocklet);
-
-    await validateBlocklet(newBlocklet);
+    // backup rollback data
+    const action = 'upgrade';
+    await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
 
-    return this._upgradeBlocklet({
+    await this.downloadAndInstall({
+      blocklet: newBlocklet,
       oldBlocklet,
-      newBlocklet,
       context: { ...context, forceStartProcessIds: [getComponentProcessId(newChild, [newBlocklet])] },
+      throwOnError: true,
+      postAction: action,
+      skipCheckStatusBeforeDownload: true,
     });
-  }
-
-  /**
-   * add to download job queue
-   * @param {string} did blocklet did
-   * @param {object} blocklet object
-   */
-  async download(did, blocklet) {
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
-    this.installQueue.push(
-      {
-        entity: 'blocklet',
-        action: 'download',
-        id: did,
-        blocklet: { ...blocklet },
-        postAction: 'install',
-      },
-      did
-    );
+    return this.getBlocklet(newBlocklet.meta.did);
   }
 
   async prune() {
@@ -2650,6 +2642,80 @@ class BlockletManager extends BaseBlockletManager {
     ];
   }
 
+  async _attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
+    if (!did) {
+      throw new Error('did should not be empty');
+    }
+
+    try {
+      const blocklet = await this.getBlocklet(did, { throwOnNotExist: false });
+
+      if (!blocklet) {
+        return null;
+      }
+
+      const fromCache = !!cachedBlocklet;
+
+      // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
+      if (fromCache) {
+        const cached = {};
+        forEachBlockletSync(cachedBlocklet, (component, { id }) => {
+          cached[id] = component;
+        });
+
+        Object.assign(blocklet, pick(cachedBlocklet, ['appRuntimeInfo', 'diskInfo']));
+
+        forEachBlockletSync(blocklet, (component, { id }) => {
+          if (cached[id]) {
+            Object.assign(component, pick(cached[id], ['runtimeInfo']));
+          }
+        });
+      }
+
+      // 处理 domainAliases#value SLOT_FOR_IP_DNS_SITE
+      if (blocklet?.site?.domainAliases?.length) {
+        const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+        blocklet.site.domainAliases = blocklet.site.domainAliases.map((x) => ({
+          ...x,
+          value: util.replaceDomainSlot({ domain: x.value, context, nodeIp }),
+        }));
+      }
+
+      // app runtime info, app status
+      blocklet.appRuntimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did);
+
+      if (!fromCache) {
+        // app disk info, component runtime info, component status, component engine
+        await forEachBlocklet(blocklet, async (component, { level }) => {
+          component.engine = getEngine(getBlockletEngineNameByPlatform(component.meta)).describe();
+
+          if (level === 0) {
+            component.diskInfo = await getDiskInfo(component, {
+              useFakeDiskInfo: !diskInfo,
+            });
+          }
+
+          component.runtimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did, component.env.id);
+
+          if (component.runtimeInfo?.status && shouldUpdateBlockletStatus(component.status)) {
+            component.status = statusMap[component.runtimeInfo.status];
+          }
+        });
+      }
+
+      return blocklet;
+    } catch (err) {
+      const simpleState = await states.blocklet.getBlocklet(did);
+      logger.error('failed to get blocklet info', {
+        did,
+        name: get(simpleState, 'meta.name'),
+        status: get(simpleState, 'status'),
+        error: err,
+      });
+      return simpleState;
+    }
+  }
+
   async _syncBlockletStatus() {
     const run = async (blocklet) => {
       try {
@@ -2728,6 +2794,11 @@ class BlockletManager extends BaseBlockletManager {
       const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
       this.emit(BlockletEvents.added, blocklet1);
 
+      const action = 'install';
+      const oldBlocklet = {
+        extraState: oldExtraState,
+      };
+
       /** @type {{
        *  blocklet: any;
        *  oldBlocklet: {
@@ -2739,16 +2810,16 @@ class BlockletManager extends BaseBlockletManager {
        * }} */
       const downloadParams = {
         blocklet: { ...blocklet1 },
-        oldBlocklet: {
-          children: children.filter((x) => x.dynamic), // let downloader skip re-downloading dynamic blocklet
-          extraState: oldExtraState,
-        },
         context,
-        postAction: 'install',
+        postAction: action,
+        oldBlocklet,
       };
 
+      // backup rollback data
+      await this._rollbackCache.backup({ did, action, oldBlocklet });
+
       if (sync) {
-        await this.onDownload({ ...downloadParams, throwOnError: true });
+        await this.downloadAndInstall({ ...downloadParams, throwOnError: true });
         return states.blocklet.getBlocklet(did);
       }
 
@@ -2859,8 +2930,11 @@ class BlockletManager extends BaseBlockletManager {
       postAction: action,
     };
 
+    // backup rollback data
+    await this._rollbackCache.backup({ did, action, oldBlocklet });
+
     if (sync) {
-      await this.onDownload({ ...downloadParams, throwOnError: true });
+      await this.downloadAndInstall({ ...downloadParams, throwOnError: true });
       return states.blocklet.getBlocklet(did);
     }
     const ticket = this.installQueue.push(
@@ -2898,6 +2972,7 @@ class BlockletManager extends BaseBlockletManager {
    */
   async _installBlocklet({ did, oldBlocklet, context }) {
     try {
+      // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
       const { meta, source, deployedFrom } = blocklet;
 
@@ -2914,13 +2989,13 @@ class BlockletManager extends BaseBlockletManager {
 
       // Add environments
       await this.updateBlockletEnvironment(meta.did);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
 
       // post install
       await this._runPostInstallHook(blocklet, context);
 
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
 
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
@@ -2956,6 +3031,8 @@ class BlockletManager extends BaseBlockletManager {
         entityId: did,
         severity: 'success',
       });
+
+      await this._rollbackCache.remove({ did: blocklet.meta.did });
       return blocklet;
     } catch (err) {
       const { meta } = await states.blocklet.getBlocklet(did);
@@ -3005,6 +3082,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
       await this._setConfigsFromMeta(did);
 
+      // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
 
       // pre install
@@ -3012,7 +3090,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // Add environments
       await this.updateBlockletEnvironment(did);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
 
       // post install
       await this._runPostInstallHook(blocklet, context);
@@ -3052,7 +3130,7 @@ class BlockletManager extends BaseBlockletManager {
         logger.info('started blocklet for upgrading', { did, version });
       }
 
-      blocklet = await this.ensureBlocklet(did, context);
+      blocklet = await this.getBlocklet(did, context);
 
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
@@ -3081,6 +3159,8 @@ class BlockletManager extends BaseBlockletManager {
       // Update dynamic component meta in blocklet settings
       await this._ensureDynamicChildrenInSettings(blocklet);
 
+      await this._rollbackCache.remove({ did: blocklet.meta.did });
+
       return blocklet;
     } catch (err) {
       const b = await this._rollback(action, did, oldBlocklet);
@@ -3144,9 +3224,11 @@ class BlockletManager extends BaseBlockletManager {
         });
         this.emit(BlockletEvents.statusChange, blocklet1);
       },
-      postDownload: async () => {
-        // since preferences only exist in blocklet bundle, we need to populate then after downloaded
-        await this._setConfigsFromMeta(did);
+      postDownload: async ({ isCancelled }) => {
+        if (!isCancelled) {
+          // since preferences only exist in blocklet bundle, we need to populate then after downloaded
+          await this._setConfigsFromMeta(did);
+        }
       },
     });
   }
@@ -3164,12 +3246,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async _cancelWaiting(blockletMeta, context) {
-    const { did } = blockletMeta;
-    return this.installQueue.cancel(did);
-  }
-
   /**
    * @param {string} action install, upgrade, downgrade
    * @param {string} did
@@ -3283,7 +3359,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _setConfigsFromMeta(did, childDid) {
-    const blocklet = await getBlocklet({ states, dataDirs: this.dataDirs, did, validateEnv: false, ensureDirs: false });
+    const blocklet = await getBlocklet({ states, dataDirs: this.dataDirs, did });
 
     if (!childDid) {
       await forEachBlocklet(blocklet, async (b, { ancestors }) => {
@@ -3337,7 +3413,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _getBlockletForInstallation(did) {
-    const blocklet = await states.blocklet.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did, { decryptSk: false });
     if (!blocklet) {
       return null;
     }
@@ -3563,7 +3639,7 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.appDidChanged, blocklet);
 
-    const blockletWithEnv = await this.ensureBlocklet(blocklet.meta.did);
+    const blockletWithEnv = await this.getBlocklet(blocklet.meta.did);
     const appSystemEnvironments = getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo);
 
     await didDocument.updateBlockletDocument({