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

package/lib/blocklet/manager/disk.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable no-await-in-loop */
 const fs = require('fs-extra');
-const { fileURLToPath } = require('url');
 const path = require('path');
 const flat = require('flat');
 const get = require('lodash/get');
@@ -17,14 +16,12 @@ const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { verifyPresentation } = require('@arcblock/vc');
-const { toBase58 } = require('@ocap/util');
 const { toSvg: createDidLogo } =
   process.env.NODE_ENV !== 'test' ? require('@arcblock/did-motif') : require('@arcblock/did-motif/dist/did-motif.cjs');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
+const sleep = require('@abtnode/util/lib/sleep');
 
 const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
-const downloadFile = require('@abtnode/util/lib/download-file');
-const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
 const {
   VC_TYPE_BLOCKLET_PURCHASE,
@@ -45,17 +42,16 @@ const {
   forEachChildSync,
   forEachBlocklet,
   getComponentId,
-  getComponentBundleId,
   isPreferenceKey,
   getRolesFromAuthConfig,
 } = require('@blocklet/meta/lib/util');
 const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
-const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { titleSchema, mountPointSchema, environmentNameSchema } = require('@blocklet/meta/lib/schema');
 const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
+const Lock = require('@abtnode/util/lib/lock');
 
 const { toExternalBlocklet } = toBlockletDid;
 
@@ -63,7 +59,6 @@ const {
   BlockletStatus,
   BlockletSource,
   BlockletEvents,
-  BLOCKLET_BUNDLE_FOLDER,
   BLOCKLET_MODES,
   BlockletGroup,
   fromBlockletStatus,
@@ -86,7 +81,6 @@ const {
 } = require('../../util/get-accessible-external-node-ip');
 const {
   getBlockletMetaFromUrl,
-  ensureBlockletExpanded,
   getAppSystemEnvironments,
   getComponentSystemEnvironments,
   getAppOverwrittenEnvironments,
@@ -99,8 +93,6 @@ const {
   checkBlockletProcessHealthy,
   validateBlocklet,
   statusMap,
-  expandTarball,
-  verifyIntegrity,
   pruneBlockletBundle,
   getDiskInfo,
   getUpdateMetaList,
@@ -110,7 +102,6 @@ const {
   checkDuplicateComponents,
   getDiffFiles,
   getBundleDir,
-  needBlockletDownload,
   findAvailableDid,
   ensureMeta,
   getBlocklet,
@@ -131,12 +122,13 @@ const runMigrationScripts = require('../migration');
 const hooks = require('../hooks');
 const { formatName, getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
 const handleInstanceInStore = require('../../util/public-to-store');
-const { getNFTState, getServerDidDomain } = require('../../util');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
 const { SpacesBackup } = require('../storage/backup/spaces');
 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 {
   isInProgress,
@@ -150,8 +142,6 @@ const {
 
 const statusLock = new Lock('blocklet-status-lock');
 
-const asyncFs = fs.promises;
-
 const pm2StatusMap = {
   online: BlockletStatus.running,
   stop: BlockletStatus.stopped,
@@ -211,15 +201,6 @@ class BlockletManager extends BaseBlockletManager {
     this.installQueue = installQueue;
     this.teamManager = teamManager;
 
-    /**
-     * { did: Map({ <childDid>: <downloadFile.cancelCtrl> }) }
-     */
-    this.downloadCtrls = {};
-    /**
-     * { [download-did-version]: Lock }
-     */
-    this.downloadLocks = {};
-
     // cached installed blocklets for performance
     this.cachedBlocklets = null;
 
@@ -231,6 +212,12 @@ class BlockletManager extends BaseBlockletManager {
 
     this.runtimeMonitor = new BlockletRuntimeMonitor({ historyLength: MONITOR_HISTORY_LENGTH, states });
 
+    this.blockletDownloader = new BlockletDownloader({
+      installDir: this.installDir,
+      downloadDir: this.dataDirs.tmp,
+      cache: states.cache,
+    });
+
     if (daemon) {
       blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid));
       blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid));
@@ -877,7 +864,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       if (blocklet.status === BlockletStatus.downloading) {
-        await this._cancelDownload(blocklet.meta, context);
+        await this.blockletDownloader.cancelDownload(blocklet.meta.did);
       } else if (blocklet.status === BlockletStatus.waiting) {
         await this._cancelWaiting(blocklet.meta, context);
       }
@@ -920,8 +907,8 @@ class BlockletManager extends BaseBlockletManager {
         const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
         return blocklet;
       } catch (e) {
-        logger.error('get blocklet detail error', { error: e.message });
-        return null;
+        logger.error('get blocklet detail error', { error: e });
+        return null; // TODO: 直接返回没有 runtime info 的数据
       }
     }
 
@@ -1549,8 +1536,7 @@ class BlockletManager extends BaseBlockletManager {
     });
     logger.info('add blocklet for dev', { did, version, meta });
 
-    const oldBlocklet = { children: children.filter((x) => x.dynamic) }; // let downloader skip re-downloading dynamic blocklet
-    await this._downloadBlocklet(added, oldBlocklet);
+    await this._downloadBlocklet(added);
 
     // Add Config
     await this._setConfigsFromMeta(did);
@@ -1614,7 +1600,7 @@ class BlockletManager extends BaseBlockletManager {
     await states.blocklet.addChildren(rootDid, [component]);
 
     const newBlocklet = await states.blocklet.getBlocklet(rootDid);
-    await this._downloadBlocklet(newBlocklet, existRoot);
+    await this._downloadBlocklet(newBlocklet);
     await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
 
     await this._upsertDynamicNavigation(existRoot.meta.did, component, { skipNavigation });
@@ -1862,7 +1848,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // download bundle
     try {
-      const { isCancelled } = await this._downloadBlocklet(blocklet, oldBlocklet, context);
+      const { isCancelled } = await this._downloadBlocklet(blocklet, context);
 
       if (isCancelled) {
         logger.info('Download was canceled', { name, did, version });
@@ -2388,7 +2374,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async _installFromUpload({ file, did, diffVersion, deleteSet, context }) {
     logger.info('install blocklet', { from: 'upload file' });
-    const { cwd, tarFile } = await this._downloadFromUpload(file);
+    const { tarFile } = await this._downloadFromUpload(file);
 
     // diff deploy
     if (did && diffVersion) {
@@ -2410,14 +2396,17 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
       }
 
-      const { meta } = await this._resolveDiffDownload(cwd, tarFile, deleteSet, oldBlocklet.meta);
+      const { meta } = await resolveDiffDownload(tarFile, this.installDir, {
+        deleteSet,
+        meta: oldBlocklet.meta,
+      });
       const newBlocklet = await states.blocklet.getBlocklet(did);
       newBlocklet.meta = ensureMeta(meta);
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
       newBlocklet.children = await this._getChildrenForInstallation(meta);
       await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet, oldBlocklet);
+      await this._downloadBlocklet(newBlocklet);
 
       return this._upgradeBlocklet({
         oldBlocklet,
@@ -2427,7 +2416,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // full deploy
-    const { meta } = await this._resolveDownload(cwd, tarFile);
+    const { meta } = await resolveDownload(tarFile, this.installDir);
     const oldBlocklet = await this._getBlockletForInstallation(meta.did);
 
     // full deploy - upgrade
@@ -2444,7 +2433,7 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.children = await this._getChildrenForInstallation(meta);
 
       await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet, oldBlocklet);
+      await this._downloadBlocklet(newBlocklet);
 
       return this._upgradeBlocklet({
         oldBlocklet,
@@ -2472,11 +2461,7 @@ class BlockletManager extends BaseBlockletManager {
       await checkDuplicateAppSk({ did: meta.did, states });
 
       // download
-      await this._downloadBlocklet(
-        blocklet,
-        // let downloader skip re-downloading dynamic blocklet
-        { children: children.filter((x) => x.dynamic) }
-      );
+      await this._downloadBlocklet(blocklet);
 
       return this._installBlocklet({
         did: meta.did,
@@ -2501,7 +2486,7 @@ class BlockletManager extends BaseBlockletManager {
   }) {
     logger.info('install blocklet', { from: 'upload file' });
     // download
-    const { cwd, tarFile } = await this._downloadFromUpload(file);
+    const { tarFile } = await this._downloadFromUpload(file);
 
     const oldBlocklet = await this._getBlockletForInstallation(rootDid);
     if (!oldBlocklet) {
@@ -2530,10 +2515,10 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error('Blocklet version changed when diff deploying');
       }
 
-      meta = (await this._resolveDiffDownload(cwd, tarFile, deleteSet, oldChild.meta)).meta;
+      meta = (await resolveDiffDownload(tarFile, this.installDir, { deleteSet, meta: oldChild.meta })).meta;
     } else {
       // full deploy
-      meta = (await this._resolveDownload(cwd, tarFile)).meta;
+      meta = (await resolveDownload(tarFile, this.installDir)).meta;
     }
 
     if (meta.did === rootDid) {
@@ -2567,7 +2552,7 @@ class BlockletManager extends BaseBlockletManager {
 
     await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild, { skipNavigation });
 
-    await this._downloadBlocklet(newBlocklet, oldBlocklet);
+    await this._downloadBlocklet(newBlocklet);
 
     await validateBlocklet(newBlocklet);
 
@@ -2649,6 +2634,7 @@ class BlockletManager extends BaseBlockletManager {
       {
         name: 'delete-expired-external-blocklet',
         time: '0 */30 * * * *', // 30min
+        options: { runOnInit: false },
         fn: () => this._deleteExpiredExternalBlocklet(),
       },
       {
@@ -2906,137 +2892,6 @@ class BlockletManager extends BaseBlockletManager {
     return newBlocklet;
   }
 
-  /**
-   * decompress file, format dir and move to installDir
-   * @param {string} cwd
-   * @param {string} tarFile
-   * @param {object} originalMeta for verification
-   * @param {object} option
-   */
-  async _resolveDownload(cwd, tarFile, originalMeta, { removeTarFile = true } = {}) {
-    const downloadDir = path.join(cwd, `${path.basename(tarFile, path.extname(tarFile))}`);
-    const tmp = `${downloadDir}-tmp`;
-    try {
-      await expandTarball({ source: tarFile, dest: tmp, strip: 0 });
-    } catch (error) {
-      logger.error('expand blocklet tar file error');
-      throw error;
-    } finally {
-      if (removeTarFile) {
-        fs.removeSync(tarFile);
-      }
-    }
-    let installDir;
-    let meta;
-    try {
-      // resolve dir
-      let dir = tmp;
-      const files = await asyncFs.readdir(dir);
-      if (files.includes('package')) {
-        dir = path.join(tmp, 'package');
-      } else if (files.length === 1) {
-        const d = path.join(dir, files[0]);
-        if ((await asyncFs.stat(d)).isDirectory()) {
-          dir = d;
-        }
-      }
-
-      if (fs.existsSync(path.join(dir, BLOCKLET_BUNDLE_FOLDER))) {
-        dir = path.join(dir, BLOCKLET_BUNDLE_FOLDER);
-      }
-
-      logger.info('Move downloadDir to installDir', { downloadDir });
-      await fs.move(dir, downloadDir, { overwrite: true });
-      fs.removeSync(tmp);
-
-      meta = getBlockletMeta(downloadDir, { ensureMain: true });
-      const { did, name, version } = meta;
-
-      // validate
-      if (
-        originalMeta &&
-        (originalMeta.did !== did || originalMeta.name !== name || originalMeta.version !== version)
-      ) {
-        logger.error('Meta has differences', { originalMeta, meta });
-        throw new Error('There are differences between the meta from tarball file and the original meta');
-      }
-      await validateBlockletEntry(downloadDir, meta);
-
-      await ensureBlockletExpanded(meta, downloadDir);
-
-      installDir = getBundleDir(this.installDir, meta);
-      if (fs.existsSync(installDir)) {
-        fs.removeSync(installDir);
-        logger.info('cleanup blocklet upgrade dir', { name, version, installDir });
-      }
-
-      fs.mkdirSync(installDir, { recursive: true });
-
-      await fs.move(downloadDir, installDir, { overwrite: true });
-    } catch (error) {
-      fs.removeSync(downloadDir);
-      fs.removeSync(tmp);
-      throw error;
-    }
-
-    return { meta, installDir };
-  }
-
-  async _resolveDiffDownload(cwd, tarFile, deleteSet, bundle) {
-    logger.info('Resolve diff download', { tarFile, cwd });
-    const downloadDir = path.join(cwd, `${path.basename(tarFile, path.extname(tarFile))}`);
-    const diffDir = `${downloadDir}-diff`;
-    try {
-      await expandTarball({ source: tarFile, dest: diffDir, strip: 0 });
-      fs.removeSync(tarFile);
-    } catch (error) {
-      fs.removeSync(tarFile);
-      logger.error('expand blocklet tar file error');
-      throw error;
-    }
-    logger.info('Copy installDir to downloadDir', { installDir: this.installDir, downloadDir });
-    await fs.copy(getBundleDir(this.installDir, bundle), downloadDir);
-    try {
-      // delete
-      logger.info('Delete files from downloadDir', { fileNum: deleteSet.length });
-      // eslint-disable-next-line no-restricted-syntax
-      for (const file of deleteSet) {
-        await fs.remove(path.join(downloadDir, file));
-      }
-      // walk & cover
-      logger.info('Move files from diffDir to downloadDir', { diffDir, downloadDir });
-      const walkDiff = async (dir) => {
-        const files = await asyncFs.readdir(dir);
-        // eslint-disable-next-line no-restricted-syntax
-        for (const file of files) {
-          const p = path.join(dir, file);
-          const stat = await asyncFs.stat(p);
-          if (stat.isDirectory()) {
-            await walkDiff(p);
-          } else if (stat.isFile()) {
-            await fs.move(p, path.join(downloadDir, path.relative(diffDir, p)), { overwrite: true });
-          }
-        }
-      };
-      await walkDiff(diffDir);
-      fs.removeSync(diffDir);
-      const meta = getBlockletMeta(downloadDir, { ensureMain: true });
-
-      await ensureBlockletExpanded(meta, downloadDir);
-
-      // move to installDir
-      const bundleDir = getBundleDir(this.installDir, meta);
-      logger.info('Move downloadDir to installDir', { downloadDir, bundleDir });
-      await fs.move(downloadDir, bundleDir, { overwrite: true });
-
-      return { meta, installDir: bundleDir };
-    } catch (error) {
-      fs.removeSync(downloadDir);
-      fs.removeSync(diffDir);
-      throw error;
-    }
-  }
-
   /**
    * @param {string} opt.did
    * @param {object} opt.context
@@ -3267,275 +3122,33 @@ class BlockletManager extends BaseBlockletManager {
     await states.blockletExtras.setSettings(did, { children: dynamicChildren });
   }
 
-  /**
-   *
-   *
-   * @param {{
-   *   url: string,
-   *   cwd: string,
-   *   tarball: string,
-   *   did: string,
-   *   integrity: string,
-   *   verify: boolean = true,
-   *   ctrlStore: {},
-   *   rootDid: string,
-   *   context: {} = {},
-   * }} { url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _downloadTarball({ url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }) {
-    fs.mkdirSync(cwd, { recursive: true });
-
-    const tarballName = url.split('/').slice(-1)[0];
-
-    const tarballPath = path.join(cwd, tarballName);
-
-    const { protocol } = new URL(url);
-
-    const cachedTarFile = await this._getCachedTarFile(integrity);
-    if (cachedTarFile) {
-      logger.info('found cache tarFile', { did, tarballName, integrity });
-      await fs.move(cachedTarFile, tarballPath, { overwrite: true });
-    } else if (protocol.startsWith('file')) {
-      await fs.copy(decodeURIComponent(fileURLToPath(url)), tarballPath);
-    } else {
-      const cancelCtrl = new downloadFile.CancelCtrl();
-
-      if (!ctrlStore[rootDid]) {
-        ctrlStore[rootDid] = new Map();
-      }
-      ctrlStore[rootDid].set(did, cancelCtrl);
-
-      const headers = context.headers ? cloneDeep(context.headers) : {};
-      const exist = (context.downloadTokenList || []).find((x) => x.did === did);
-      if (exist) {
-        headers['x-download-token'] = exist.token;
-      }
-
-      await downloadFile(url, path.join(cwd, tarballName), { cancelCtrl }, { ...context, headers });
-
-      if (ctrlStore[rootDid]) {
-        ctrlStore[rootDid].delete(did);
-        if (!ctrlStore[rootDid].size) {
-          delete ctrlStore[rootDid];
-        }
-      }
-
-      if (cancelCtrl.isCancelled) {
-        return downloadFile.CANCEL;
-      }
-    }
-
-    if (verify) {
-      try {
-        await verifyIntegrity({ file: tarballPath, integrity });
-      } catch (error) {
-        logger.error('verify integrity error', { error, tarball, url });
-        throw new Error(`${tarball} integrity check failed.`);
-      }
-    }
-
-    return tarballPath;
-  }
-
-  /**
-   * use LRU algorithm
-   */
-  async _addCacheTarFile(tarballPath, integrity) {
-    // eslint-disable-next-line no-param-reassign
-    integrity = toBase58(integrity);
-
-    // move tarball to cache dir
-    const cwd = path.join(this.dataDirs.tmp, 'download-cache');
-    const cachePath = path.join(cwd, `${integrity}.tar.gz`);
-    await fs.ensureDir(cwd);
-    await fs.move(tarballPath, cachePath, { overwrite: true });
-
-    const key = 'blocklet:manager:downloadCache';
-    const cacheList = (await states.cache.get(key)) || [];
-    const exist = cacheList.find((x) => x.integrity === integrity);
-
-    // update
-    if (exist) {
-      logger.info('update cache tarFile', { base58: integrity });
-      exist.accessAt = Date.now();
-      await states.cache.set(key, cacheList);
-      return;
-    }
-
-    // add
-    cacheList.push({ integrity, accessAt: Date.now() });
-    if (cacheList.length > 10) {
-      // find and remove
-      let minIndex = 0;
-      let min = cacheList[0];
-      cacheList.forEach((x, i) => {
-        if (x.accessAt < min.accessAt) {
-          minIndex = i;
-          min = x;
-        }
-      });
-
-      cacheList.splice(minIndex, 1);
-      await fs.remove(path.join(cwd, `${min.integrity}.tar.gz`));
-      logger.info('remove cache tarFile', { base58: min.integrity });
-    }
-    logger.info('add cache tarFile', { base58: integrity });
-
-    // update
-    await states.cache.set(key, cacheList);
-  }
-
-  async _getCachedTarFile(integrity) {
-    // eslint-disable-next-line no-param-reassign
-    integrity = toBase58(integrity);
-
-    const cwd = path.join(this.dataDirs.tmp, 'download-cache');
-    const cachePath = path.join(cwd, `${integrity}.tar.gz`);
-
-    if (fs.existsSync(cachePath)) {
-      return cachePath;
-    }
-
-    return null;
-  }
-
-  /**
-   *
-   *
-   * @param {*} meta
-   * @param {*} rootDid
-   * @param {*} url
-   * @param {{}} [context={}]
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _downloadBundle(meta, rootDid, url, context = {}) {
-    const { bundleName: name, bundleDid: did, version, dist = {} } = meta;
-    const { tarball, integrity } = dist;
-
-    const lockName = `download-${did}-${version}`;
-    let lock = this.downloadLocks[lockName];
-    if (!lock) {
-      lock = new Lock(lockName);
-      this.downloadLocks[lockName] = lock;
-    }
-
-    try {
-      await lock.acquire();
-      logger.info('downloaded blocklet for installing', { name, version, tarball, integrity });
-      const cwd = path.join(this.dataDirs.tmp, 'download', name);
-      await fs.ensureDir(cwd);
-      logger.info('start download blocklet', { name, version, cwd, tarball, integrity });
-      const tarballPath = await this._downloadTarball({
-        name,
-        did,
-        version,
-        cwd,
-        tarball,
-        integrity,
-        verify: true,
-        ctrlStore: this.downloadCtrls,
-        rootDid,
-        url,
-        context,
-      });
-      logger.info('downloaded blocklet tar file', { name, version, tarballPath });
-      if (tarballPath === downloadFile.CANCEL) {
-        lock.release();
-        return { isCancelled: true };
-      }
-
-      // resolve tarball and mv tarball to cache after resolved
-      await this._resolveDownload(cwd, tarballPath, null, { removeTarFile: false });
-      await this._addCacheTarFile(tarballPath, integrity);
-
-      logger.info('resolved blocklet tar file to install dir', { name, version });
-      lock.release();
-      return { isCancelled: false };
-    } catch (error) {
-      lock.release();
-      throw error;
-    }
-  }
-
   /**
    *
    *
    * @param {{}} blocklet
-   * @param {{}} [oldBlocklet={}]
    * @param {{}} [context={}]
    * @return {*}
    * @memberof BlockletManager
    */
-  async _downloadBlocklet(blocklet, oldBlocklet = {}, context = {}) {
+  async _downloadBlocklet(blocklet, context = {}) {
     const {
-      meta: { name, did },
+      meta: { did },
     } = blocklet;
 
-    const oldComponentObj = {};
-    const downloadComponentIds = [];
-    const metaObj = {};
-    const metas = [];
-
-    forEachBlockletSync(oldBlocklet, (oldComponent, { id }) => {
-      if (oldComponent.meta) {
-        oldComponentObj[id] = oldComponent;
-        metaObj[getComponentBundleId(oldComponent)] = oldComponent.meta;
-      }
-    });
-
-    forEachBlockletSync(blocklet, (component, { id: componentId }) => {
-      if (needBlockletDownload(component, oldComponentObj[componentId])) {
-        const bundleId = getComponentBundleId(component);
-
-        if (metaObj[bundleId]) {
-          if (get(component, 'meta.dist.integrity') !== get(metaObj[bundleId], 'dist.integrity')) {
-            // FIXME: what should we do if component bundle integrity not same in different apps
-            logger.error(`find duplicate bundle with different integrity when downloading ${blocklet.meta.title}`, {
-              bundleId,
-            });
-          }
-
-          logger.info(`skip download duplicate bundle ${bundleId}`);
-          return;
-        }
-
-        metaObj[bundleId] = component.meta;
-        metas.push(component.meta);
-        downloadComponentIds.push(componentId);
-      }
-    });
-
-    // update children status
-    const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
-      children: downloadComponentIds,
+    return this.blockletDownloader.download(blocklet, {
+      ...context,
+      preDownload: async ({ downloadComponentIds }) => {
+        // update children status
+        const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
+          children: downloadComponentIds,
+        });
+        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);
+      },
     });
-    this.emit(BlockletEvents.statusChange, blocklet1);
-
-    try {
-      logger.info('Download Blocklet', { name, did, bundles: metas.map((x) => get(x, 'dist.tarball')) });
-      const tasks = [];
-      for (const meta of metas) {
-        const url = meta.dist.tarball;
-        tasks.push(this._downloadBundle(meta, did, url, context));
-      }
-      const results = await Promise.all(tasks);
-
-      // since preferences only exist in blocklet bundle, we need to populate then after downloaded
-      await this._setConfigsFromMeta(did);
-
-      if (results.find((x) => x.isCancelled)) {
-        return { isCancelled: true };
-      }
-    } catch (error) {
-      logger.error('Download blocklet failed', { did, name, error });
-      await this._cancelDownload(blocklet.meta);
-      throw error;
-    }
-
-    return { isCancelled: false };
   }
 
   async _syncPm2Status(pm2Status, did) {
@@ -3551,17 +3164,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async _cancelDownload(blockletMeta, context) {
-    const { did } = blockletMeta;
-
-    if (this.downloadCtrls[did]) {
-      for (const cancelCtrl of this.downloadCtrls[did].values()) {
-        cancelCtrl.cancel();
-      }
-    }
-  }
-
   // eslint-disable-next-line no-unused-vars
   async _cancelWaiting(blockletMeta, context) {
     const { did } = blockletMeta;
@@ -3848,48 +3450,55 @@ class BlockletManager extends BaseBlockletManager {
   async _deleteExpiredExternalBlocklet() {
     try {
       logger.info('start check expired external blocklet');
-      const blocklets = await states.blocklet.getBlocklets({
-        controller: {
-          $exists: true,
+      const blockletExtras = await states.blockletExtras.find(
+        {
+          controller: {
+            $exists: true,
+          },
+          'controller.expiredAt': {
+            $exists: false,
+          },
         },
-      });
-
-      const nodeInfo = await states.node.read();
+        { did: 1, meta: 1, controller: 1 }
+      );
 
-      const tasks = blocklets.map(async (blocklet) => {
+      for (const data of blockletExtras) {
         try {
-          const assetState = await getNFTState(nodeInfo.launcher.chainHost, blocklet.controller.nftId);
+          const assetState = await util.getNFTState(data.controller.chainHost, data.controller.nftId);
           const isExpired = isNFTExpired(assetState);
+
           if (isExpired) {
             logger.info('the blocklet already expired', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
+              blockletDid: data.meta.did,
+              nftId: data.controller.nftId,
             });
 
-            await this.delete({ did: blocklet.meta.did, keepData: true, keepConfigs: true, keepLogsDir: true });
+            await this.delete({ did: data.meta.did, keepData: true, keepConfigs: true, keepLogsDir: true });
             logger.info('the expired blocklet already deleted', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
-              did: blocklet.meta.did,
+              blockletDid: data.meta.did,
+              nftId: data.controller.nftId,
             });
 
             const expiredAt = getNftExpirationDate(assetState);
-            await states.blockletExtras.updateExpireInfo({ did: blocklet.meta.did, expiredAt });
+            await states.blockletExtras.updateExpireInfo({ did: data.meta.did, expiredAt });
             logger.info('updated expired blocklet extra info', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
-              did: blocklet.meta.did,
+              nftId: data.controller.nftId,
+              blockletDid: data.meta.did,
             });
+
+            // 删除 blocklet 后会 reload nginx, 所以这里每次删除一个
+            if (process.env.NODE_ENV !== 'test') {
+              await sleep(10 * 1000);
+            }
           }
         } catch (error) {
-          logger.error('get asset state failed when check expired external blocklet', {
-            blockletId: blocklet._id,
-            nftId: blocklet.controller.nftId,
+          logger.error('delete expired blocklet failed', {
+            blockletDid: data.meta.did,
+            nftId: data.controller.nftId,
+            error,
           });
         }
-      });
-
-      await Promise.all(tasks);
+      }
 
       logger.info('check expired external blocklet end');
     } catch (error) {
@@ -3960,7 +3569,7 @@ class BlockletManager extends BaseBlockletManager {
     await didDocument.updateBlockletDocument({
       wallet,
       blockletAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
-      daemonDidDomain: getServerDidDomain(nodeInfo),
+      daemonDidDomain: util.getServerDidDomain(nodeInfo),
       didRegistryUrl: nodeInfo.didRegistry,
       domain: nodeInfo.didDomain,
     });