@abtnode/core 1.7.19 → 1.7.20

package/lib/blocklet/manager/disk.js

@@ -29,10 +29,17 @@ const {
   isFreeBlocklet,
   isComponentBlocklet,
   isDeletableBlocklet,
-  getRequiredMissingConfigs,
+  getAppMissingConfigs,
   hasRunnableComponent,
+  forEachBlockletSync,
+  forEachChildSync,
   forEachBlocklet,
+  forEachChild,
+  getComponentId,
+  getComponentName,
+  getComponentBundleId,
 } = 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');
@@ -57,6 +64,7 @@ const {
   BLOCKLET_DEFAULT_VERSION,
   BLOCKLET_LATEST_SPEC_VERSION,
   BLOCKLET_META_FILE,
+  BLOCKLET_CONFIGURABLE_KEY,
 } = require('@blocklet/meta/lib/constants');
 const util = require('../../util');
 const {
@@ -64,13 +72,13 @@ const {
   getFromCache: getAccessibleExternalNodeIp,
 } = require('../../util/get-accessible-external-node-ip');
 const {
-  getBlockletDirs,
+  getComponentDirs,
   getBlockletMetaFromUrl,
   fillBlockletConfigs,
   ensureBlockletExpanded,
-  getRootSystemEnvironments,
-  getSystemEnvironments,
-  getOverwrittenEnvironments,
+  getAppSystemEnvironments,
+  getComponentSystemEnvironments,
+  getAppOverwrittenEnvironments,
   getHealthyCheckTimeout,
   startBlockletProcess,
   stopBlockletProcess,
@@ -89,7 +97,6 @@ const {
   getRuntimeEnvironments,
   getSourceFromInstallParams,
   parseChildrenFromMeta,
-  parseChildren,
   checkDuplicateComponents,
   getDiffFiles,
   getBundleDir,
@@ -136,6 +143,31 @@ const pm2StatusMap = {
  */
 const getBlockletEngineNameByPlatform = (blockletMeta) => getBlockletEngine(blockletMeta).interpreter;
 
+const getSkippedProcessIds = ({ newBlocklet, oldBlocklet, context = {} }) => {
+  const { forceStartProcessIds = [] } = context;
+  const idMap = {};
+  const res = [];
+
+  forEachBlockletSync(oldBlocklet, (b, { ancestors }) => {
+    if (b.meta.dist?.integrity) {
+      idMap[getComponentProcessId(b, ancestors)] = b.meta.dist?.integrity;
+    }
+  });
+
+  forEachBlockletSync(newBlocklet, (b, { ancestors }) => {
+    const id = getComponentProcessId(b, ancestors);
+    if (forceStartProcessIds.includes(id)) {
+      return;
+    }
+
+    if (!b.meta.dist?.integrity || b.meta.dist.integrity === idMap[id]) {
+      res.push(id);
+    }
+  });
+
+  return res;
+};
+
 class BlockletManager extends BaseBlockletManager {
   /**
    * @param {*} dataDirs generate by ../../util:getDataDirs
@@ -298,7 +330,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // check required config
-      const missingProps = getRequiredMissingConfigs(blocklet);
+      const missingProps = getAppMissingConfigs(blocklet);
       if (missingProps.length) {
         throw new Error(
           `Missing required configuration to start the blocklet: ${missingProps.map((x) => x.key).join(',')}`
@@ -319,11 +351,12 @@ class BlockletManager extends BaseBlockletManager {
       // start process
       const nodeEnvironments = await states.node.getEnvironments();
       await startBlockletProcess(blocklet, {
-        preStart: (b) =>
+        ...context,
+        preStart: (b, { env }) =>
           hooks.preStart(b, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+            env,
             did, // root blocklet did,
           }),
         nodeEnvironments,
@@ -380,7 +413,7 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('stop blocklet', { did });
 
     const blocklet = await this.ensureBlocklet(did);
-    const { appId } = blocklet.env;
+    const { processId } = blocklet.env;
 
     if (updateStatus) {
       await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
@@ -391,11 +424,11 @@ class BlockletManager extends BaseBlockletManager {
     const nodeEnvironments = await states.node.getEnvironments();
 
     await stopBlockletProcess(blocklet, {
-      preStop: (b) =>
-        hooks.preStop(b.env.appId, {
+      preStop: (b, { ancestors }) =>
+        hooks.preStop(b.env.processId, {
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+          env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
           did, // root blocklet did
           notification: states.notification,
           context,
@@ -404,7 +437,7 @@ class BlockletManager extends BaseBlockletManager {
         }),
     });
 
-    logger.info('blocklet stopped successfully', { appId, did });
+    logger.info('blocklet stopped successfully', { processId, did });
 
     if (updateStatus) {
       const res = await this.status(did, { forceSync: true });
@@ -467,11 +500,11 @@ class BlockletManager extends BaseBlockletManager {
       const nodeEnvironments = await states.node.getEnvironments();
 
       await deleteBlockletProcess(blocklet, {
-        preDelete: (b) =>
-          hooks.preUninstall(b.env.appId, {
+        preDelete: (b, { ancestors }) =>
+          hooks.preUninstall(b.env.processId, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+            env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
             did, // root blocklet did
             notification: states.notification,
             context,
@@ -515,7 +548,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // Reset config in db
       await states.blockletExtras.remove({ did: blocklet.meta.did });
-      await this._setConfigs(did);
+      await this._setConfigsFromMeta(did);
       await this.updateBlockletEnvironment(did);
       await this.resetSiteByDid(did, context);
     } else {
@@ -532,8 +565,8 @@ class BlockletManager extends BaseBlockletManager {
       fs.removeSync(logsDir);
 
       // Reset config in db
-      await states.blockletExtras.delChildConfigs(blocklet.meta.did, child.meta.did);
-      await this._setConfigs(blocklet.meta.did, child.meta.did);
+      await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
+      await this._setConfigsFromMeta(blocklet.meta.did, child.meta.did);
       await this.updateBlockletEnvironment(did);
     }
 
@@ -545,17 +578,16 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('delete blocklet component', { did, rootDid, keepData });
 
     const blocklet = await this.ensureBlocklet(rootDid);
-    const doc = await states.blocklet.getBlocklet(rootDid);
-
-    const child = doc.children.find((x) => x.meta.did === did);
-
+    const child = blocklet.children.find((x) => x.meta.did === did);
     if (!child) {
       throw new Error('Component does not exist');
     }
 
+    // delete state
+    const doc = await states.blocklet.getBlocklet(rootDid);
     doc.children = doc.children.filter((x) => x.meta.did !== did);
     const children = (await this._getDynamicChildrenFromSettings(blocklet.meta.did)).filter((x) => x.meta.did !== did);
-    if (keepState !== false) {
+    if (keepData !== false && keepState !== false) {
       children.push({
         meta: pick(child.meta, ['did', 'name', 'bundleDid', 'bundleName', 'version', 'title', 'description']),
         mountPoint: child.mountPoint,
@@ -565,7 +597,21 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     await states.blocklet.updateBlocklet(rootDid, doc);
-    states.blockletExtras.setSettings(blocklet.meta.did, { children });
+    states.blockletExtras.setSettings(doc.meta.did, { children });
+
+    // delete process
+    try {
+      const skippedProcessIds = [];
+      forEachBlockletSync(blocklet, (b) => {
+        if (!b.env.id.startsWith(child.env.id)) {
+          skippedProcessIds.push(b.env.processId);
+        }
+      });
+      await deleteBlockletProcess(blocklet, { skippedProcessIds });
+      logger.info('delete blocklet process for deleting component', { did, rootDid });
+    } catch (err) {
+      logger.error('delete blocklet process for deleting component', { did, rootDid, error: err });
+    }
 
     // delete navigation
     const navigation = await states.blockletExtras.getSettings(blocklet.meta.did, 'navigation', []);
@@ -582,7 +628,7 @@ class BlockletManager extends BaseBlockletManager {
     fs.removeSync(logsDir);
     if (keepData === false) {
       fs.removeSync(dataDir);
-      await states.blockletExtras.delChildConfigs(blocklet.meta.did, child.meta.did);
+      await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
     }
 
     const newBlocklet = await this.ensureBlocklet(rootDid);
@@ -620,7 +666,7 @@ class BlockletManager extends BaseBlockletManager {
 
     logger.info('delete blocklet process', { did });
 
-    await deleteBlockletProcess(blocklet);
+    await deleteBlockletProcess(blocklet, context);
 
     const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
     logger.info('blocklet process deleted successfully', { did });
@@ -683,23 +729,31 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   // eslint-disable-next-line no-unused-vars
-  async config({ did, childDid, configs: newConfigs, skipHook }, context) {
-    logger.info('config blocklet', { did });
+  async config({ did, configs: newConfigs, skipHook }, context) {
     if (!Array.isArray(newConfigs)) {
       throw new Error('configs list is not an array');
     }
 
-    let blocklet = await this.ensureBlocklet(did);
-    if (childDid) {
+    const dids = Array.isArray(did) ? did : [did];
+    const [rootDid, ...childDids] = dids;
+    logger.info('config blocklet', { dids });
+
+    let blocklet = await this.ensureBlocklet(rootDid);
+    for (const childDid of childDids) {
       blocklet = blocklet.children.find((x) => x.meta.did === childDid);
       if (!blocklet) {
-        throw new Error('Child blocklet does not exist', { did, childDid });
+        throw new Error('Child blocklet does not exist', { dids });
       }
     }
 
     // run hook
     const nodeEnvironments = await states.node.getEnvironments();
     for (const x of newConfigs) {
+      if (BLOCKLET_CONFIGURABLE_KEY[x.key] && !!childDids.length) {
+        logger.error(`Cannot set ${x.key} to child blocklet`, [dids]);
+        throw new Error(`Cannot set ${x.key} to child blocklet`);
+      }
+
       if (x.key === 'BLOCKLET_APP_SK') {
         try {
           fromSecretKey(x.value);
@@ -752,7 +806,7 @@ class BlockletManager extends BaseBlockletManager {
 
     if (!skipHook) {
       // FIXME: we should also call preConfig for child blocklets
-      await hooks.preConfig(blocklet.env.appId, {
+      await hooks.preConfig(blocklet.env.processId, {
         appDir: blocklet.env.appDir,
         hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
         exitOnError: true,
@@ -763,20 +817,11 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // update db
-    const configs = childDid
-      ? await states.blockletExtras.setChildConfigs(did, childDid, newConfigs)
-      : await states.blockletExtras.setConfigs(did, newConfigs);
-
-    const newState = await this.updateBlockletEnvironment(did);
+    await states.blockletExtras.setConfigs(dids, newConfigs);
+    await this.updateBlockletEnvironment(rootDid);
 
     // response
-    if (!childDid) {
-      newState.configs = configs;
-    } else {
-      const c = newState.children.find((x) => x.meta.did === childDid);
-      c.configs = configs;
-    }
-
+    const newState = await this.ensureBlocklet(rootDid);
     this.emit(BlockletEvents.updated, newState);
     return newState;
   }
@@ -915,24 +960,29 @@ class BlockletManager extends BaseBlockletManager {
 
   async checkChildrenForUpdates({ did }) {
     const blocklet = await states.blocklet.getBlocklet(did);
-    const newStaticChildren = await parseChildrenFromMeta(blocklet.meta);
-
-    const oldDynamicChildren = await this._getDynamicChildrenFromSettings(blocklet.meta.did, { skipDeleted: true });
-    const noneBundleSourceChildren = oldDynamicChildren.filter((x) => !x.bundleSource);
-    const dynamicConfig = oldDynamicChildren
-      .filter((x) => x.bundleSource)
-      .map((x) => ({ source: x.bundleSource, name: x.meta.name, title: x.meta.title, mountPoint: x.mountPoint }));
-    const newDynamicChildren = [
-      ...noneBundleSourceChildren,
-      ...(await parseChildrenFromMeta(dynamicConfig, { dynamic: true })),
-    ];
 
-    checkDuplicateComponents([...newDynamicChildren, ...newStaticChildren]);
+    const newChildren = [];
 
-    const updateList = getUpdateMetaList(
-      [...blocklet.children.map((x) => x.meta), ...oldDynamicChildren.map((x) => x.meta)],
-      [...newStaticChildren.map((x) => x.meta), ...newDynamicChildren.map((x) => x.meta)]
-    );
+    for (const child of blocklet.children || []) {
+      if (child.bundleSource) {
+        const config = {
+          source: child.bundleSource,
+          name: child.meta.name,
+          title: child.meta.title,
+          mountPoint: child.mountPoint,
+        };
+        newChildren.push(...(await parseChildrenFromMeta([config], { dynamic: child.dynamic })));
+      } else {
+        newChildren.push({
+          ...child,
+          children: await parseChildrenFromMeta(child.meta),
+        });
+      }
+    }
+
+    checkDuplicateComponents(newChildren);
+
+    const updateList = getUpdateMetaList(blocklet, { ...blocklet, children: newChildren });
 
     if (!updateList.length) {
       return {};
@@ -941,8 +991,7 @@ class BlockletManager extends BaseBlockletManager {
     // start session
     const { id: updateId } = await states.session.start({
       did,
-      staticChildren: newStaticChildren,
-      dynamicChildren: newDynamicChildren,
+      children: newChildren,
     });
 
     return {
@@ -962,8 +1011,7 @@ class BlockletManager extends BaseBlockletManager {
     } else {
       const sessionData = await states.session.end(updateId);
       did = sessionData.did;
-      const { staticChildren = [], dynamicChildren = [] } = sessionData;
-      children = [...staticChildren, ...dynamicChildren.map((x) => ({ ...x, dynamic: true }))];
+      children = sessionData.children;
       oldBlocklet = await this._getBlockletForInstallation(did);
     }
 
@@ -1070,7 +1118,7 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
-    const children = await this._getChildren(meta);
+    const children = await this._getChildrenForInstallation(meta);
     await validateBlocklet({ meta, children });
     const added = await states.blocklet.addBlocklet({
       meta,
@@ -1086,7 +1134,7 @@ class BlockletManager extends BaseBlockletManager {
     await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
     // Add environments
-    await this._setConfigs(did);
+    await this._setConfigsFromMeta(did);
     await this.updateBlockletEnvironment(did);
 
     const blocklet = await this.ensureBlocklet(did);
@@ -1121,7 +1169,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const defaultPath = formatName(meta.name);
-    const children = await parseChildren([
+    const children = [
       {
         meta: ensureMeta(meta),
         mountPoint: mountPoint || `/${defaultPath}`,
@@ -1130,18 +1178,24 @@ class BlockletManager extends BaseBlockletManager {
         status: BlockletStatus.installed,
         mode: BLOCKLET_MODES.DEVELOPMENT,
         dynamic: true,
+        children: await parseChildrenFromMeta(meta, { ancestors: [{ mountPoint: mountPoint || `/${defaultPath}` }] }),
       },
-    ]);
+    ];
     await validateBlocklet(children[0]);
     await states.blocklet.addChildren(rootDid, children);
-    await this._upsertDynamicNavigation(existRoot.meta.did, children[0]);
 
-    logger.info('add blocklet component for dev', { did, version, meta });
+    const newBlocklet = await states.blocklet.getBlocklet(rootDid);
+    await this._downloadBlocklet(newBlocklet, existRoot);
+    await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
+
+    await this._upsertDynamicNavigation(existRoot.meta.did, children[0]);
 
     // Add environments
-    await this._setConfigs(rootDid);
+    await this._setConfigsFromMeta(rootDid);
     await this.updateBlockletEnvironment(rootDid);
 
+    logger.info('add blocklet component for dev', { did, version, meta });
+
     const rootBlocklet = await this.ensureBlocklet(rootDid);
 
     return rootBlocklet;
@@ -1157,56 +1211,34 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error(`Can not find blocklet in database by did ${did}`);
     }
 
-    // env
-    blocklet.env = {
-      appId: blocklet.meta.name,
-      // dataDir is /dataDir.data/blocklet.meta.name
-      // cacheDir is /dataDirs.cache/blocklet.meta.name
-      // logDir is /dataDirs.log/blocklet.meta.name
-      ...getBlockletDirs(blocklet, {
-        dataDirs: this.dataDirs,
-        ensure: true,
-        e2eMode,
-        validate: validateEnv,
-      }),
-    };
-
-    // configs
-    const configs = await states.blockletExtras.getConfigs(blocklet.meta.did);
-    fillBlockletConfigs(blocklet, configs);
-
-    // settings
+    // app settings
     const settings = await states.blockletExtras.getSettings(blocklet.meta.did);
     blocklet.trustedPassports = get(settings, 'trustedPassports') || [];
     blocklet.enablePassportIssuance = get(settings, 'enablePassportIssuance', true);
     blocklet.settings = settings || {};
 
-    // site
+    // app site
     blocklet.site = await this.getSiteByDid(blocklet.meta.did);
 
-    // handle child env
-    for (const child of blocklet.children) {
-      const {
-        meta: { did: childDid, name: childName },
-      } = child;
-      const {
-        meta: { name },
-      } = blocklet;
-
-      // child env
-      child.env = {
-        appId: `${encodeURIComponent(name)}/${encodeURIComponent(childName)}`,
-        ...getBlockletDirs(child, {
+    await forEachBlocklet(blocklet, async (component, { id, level, ancestors }) => {
+      // component env
+      component.env = {
+        id,
+        name: getComponentName(component, ancestors),
+        processId: getComponentProcessId(component, ancestors),
+        ...getComponentDirs(component, {
           dataDirs: this.dataDirs,
           ensure: true,
-          rootBlocklet: blocklet,
+          validate: validateEnv,
+          ancestors,
+          e2eMode: level === 0 ? e2eMode : false,
         }),
       };
 
-      // child configs
-      const childConfigs = await states.blockletExtras.getChildConfigs(blocklet.meta.did, childDid);
-      fillBlockletConfigs(child, childConfigs, blocklet);
-    }
+      // component config
+      const configs = await states.blockletExtras.getConfigs([...ancestors.map((x) => x.meta.did), component.meta.did]);
+      fillBlockletConfigs(component, configs);
+    });
 
     return blocklet;
   }
@@ -1295,8 +1327,8 @@ class BlockletManager extends BaseBlockletManager {
         try {
           const app = blocklet.meta.group === BlockletGroup.gateway ? blocklet.children[0] : blocklet;
           if (app) {
-            const { appId } = app.env;
-            blocklet.runtimeInfo = await getRuntimeInfo(appId);
+            const { processId } = app.env;
+            blocklet.runtimeInfo = await getRuntimeInfo(processId);
             if (blocklet.runtimeInfo.status && shouldUpdateBlockletStatus(blocklet.status)) {
               blocklet.status = statusMap[blocklet.runtimeInfo.status];
             }
@@ -1312,24 +1344,24 @@ class BlockletManager extends BaseBlockletManager {
           }
         }
 
-        await Promise.all(
-          blocklet.children.map(async (child) => {
-            child.engine = getEngine(getBlockletEngineNameByPlatform(child.meta)).describe();
-            child.diskInfo = await getDiskInfo(child, {
-              useFakeDiskInfo: !diskInfo,
-            });
-            if (child.meta.group !== BlockletGroup.gateway) {
-              try {
-                child.runtimeInfo = await getRuntimeInfo(child.env.appId);
-                child.status = statusMap[blocklet.runtimeInfo.status];
-              } catch (err) {
-                if (err.code !== 'BLOCKLET_PROCESS_404') {
-                  logger.error('failed to construct blocklet runtime info', { did, error: err });
-                }
+        await forEachChild(blocklet, async (child) => {
+          child.engine = getEngine(getBlockletEngineNameByPlatform(child.meta)).describe();
+          child.diskInfo = await getDiskInfo(child, {
+            useFakeDiskInfo: !diskInfo,
+          });
+          if (child.meta.group !== BlockletGroup.gateway) {
+            try {
+              child.runtimeInfo = await getRuntimeInfo(child.env.processId);
+              if (child.runtimeInfo.status && shouldUpdateBlockletStatus(child.status)) {
+                child.status = statusMap[child.runtimeInfo.status];
+              }
+            } catch (err) {
+              if (err.code !== 'BLOCKLET_PROCESS_404') {
+                logger.error('failed to construct blocklet runtime info', { did, error: err });
               }
             }
-          })
-        );
+          }
+        });
       }
 
       return blocklet;
@@ -1459,7 +1491,7 @@ class BlockletManager extends BaseBlockletManager {
       });
 
       if (context.startImmediately) {
-        const missingProps = getRequiredMissingConfigs(installedBlocklet);
+        const missingProps = getAppMissingConfigs(installedBlocklet);
         if (!missingProps.length) {
           try {
             logger.info('start blocklet after installed', { did });
@@ -1538,29 +1570,37 @@ class BlockletManager extends BaseBlockletManager {
     const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
 
-    const rootSystemEnvironments = {
-      ...getRootSystemEnvironments(blockletWithEnv, nodeInfo),
-      ...getOverwrittenEnvironments(blockletWithEnv, nodeInfo),
+    const appSystemEnvironments = {
+      ...getAppSystemEnvironments(blockletWithEnv, nodeInfo),
+      ...getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo),
     };
 
-    // fill environments to blocklet and blocklet.children
+    // fill environments to blocklet and components
     blocklet.environments = formatEnvironments({
-      ...getSystemEnvironments(blockletWithEnv),
-      ...rootSystemEnvironments,
+      ...getComponentSystemEnvironments(blockletWithEnv),
+      ...appSystemEnvironments,
+    });
+
+    const envMap = {};
+    forEachBlockletSync(blockletWithEnv, (child, { ancestors }) => {
+      const id = getComponentId(child, ancestors);
+      envMap[id] = child;
     });
 
-    for (const child of blocklet.children) {
-      const childWithEnv = blockletWithEnv.children.find((x) => x.meta.did === child.meta.did);
+    forEachChildSync(blocklet, (child, { ancestors }) => {
+      const id = getComponentId(child, ancestors);
+
+      const childWithEnv = envMap[id];
       if (childWithEnv) {
         child.environments = formatEnvironments({
-          ...getSystemEnvironments(childWithEnv), // system env of child blocklet
-          ...rootSystemEnvironments, // system env of root blocklet
+          ...getComponentSystemEnvironments(childWithEnv), // system env of child blocklet
+          ...appSystemEnvironments, // system env of root blocklet
         });
       }
-    }
+    });
 
     // put BLOCKLET_APP_ID at root level for indexing
-    blocklet.appDid = rootSystemEnvironments.BLOCKLET_APP_ID;
+    blocklet.appDid = appSystemEnvironments.BLOCKLET_APP_ID;
 
     // update state to db
     return states.blocklet.updateBlocklet(did, blocklet);
@@ -1653,10 +1693,6 @@ class BlockletManager extends BaseBlockletManager {
 
     const meta = await getBlockletMetaFromUrl(url);
 
-    if (meta.did === rootDid) {
-      throw new Error('Cannot add self as a component');
-    }
-
     if (!isComponentBlocklet(meta)) {
       throw new Error('The blocklet cannot be a component');
     }
@@ -1678,14 +1714,15 @@ class BlockletManager extends BaseBlockletManager {
       did = found.did;
     }
 
-    const newChildren = await parseChildren([
+    const newChildren = [
       {
         meta: ensureMeta(meta, { did, name }),
         mountPoint,
         bundleSource: { url },
         dynamic: true,
+        children: await parseChildrenFromMeta(meta, { ...context, ancestors: [{ mountPoint }] }),
       },
-    ]);
+    ];
 
     checkDuplicateComponents([...blocklet.children, ...newChildren]);
 
@@ -1735,7 +1772,7 @@ class BlockletManager extends BaseBlockletManager {
       meta,
       source: BlockletSource.custom,
     });
-    await this._setConfigs(did);
+    await this._setConfigsFromMeta(did);
 
     // fake install bundle
     const bundleDir = getBundleDir(this.installDir, meta);
@@ -1801,14 +1838,14 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.meta = ensureMeta(meta);
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
-      newBlocklet.children = await this._getChildren(meta);
+      newBlocklet.children = await this._getChildrenForInstallation(meta);
       await validateBlocklet(newBlocklet);
       await this._downloadBlocklet(newBlocklet, oldBlocklet);
 
       return this._upgradeBlocklet({
         oldBlocklet,
         newBlocklet,
-        context,
+        context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
       });
     }
 
@@ -1827,7 +1864,7 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.meta = ensureMeta(meta);
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
-      newBlocklet.children = await this._getChildren(meta);
+      newBlocklet.children = await this._getChildrenForInstallation(meta);
 
       await validateBlocklet(newBlocklet);
       await this._downloadBlocklet(newBlocklet, oldBlocklet);
@@ -1835,13 +1872,14 @@ class BlockletManager extends BaseBlockletManager {
       return this._upgradeBlocklet({
         oldBlocklet,
         newBlocklet,
-        context,
+        context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
       });
     }
 
     // full deploy - install
+
     const oldExtraState = await states.blockletExtras.findOne({ did: meta.did });
-    const children = await this._getChildren(meta);
+    const children = await this._getChildrenForInstallation(meta);
     const blocklet = await states.blocklet.addBlocklet({
       meta,
       source: BlockletSource.upload,
@@ -1849,21 +1887,26 @@ class BlockletManager extends BaseBlockletManager {
       children,
     });
 
-    await validateBlocklet(blocklet);
+    try {
+      await this._setConfigsFromMeta(meta.did);
+      await validateBlocklet(blocklet);
 
-    await this._setConfigs(meta.did);
+      // download
+      await this._downloadBlocklet(
+        blocklet,
+        // let downloader skip re-downloading dynamic blocklet
+        { children: children.filter((x) => x.dynamic) }
+      );
 
-    // download
-    await this._downloadBlocklet(
-      blocklet,
-      // let downloader skip re-downloading dynamic blocklet
-      { children: children.filter((x) => x.dynamic) }
-    );
-    return this._installBlocklet({
-      did: meta.did,
-      context,
-      oldBlocklet: { extraState: oldExtraState },
-    });
+      return this._installBlocklet({
+        did: meta.did,
+        context,
+        oldBlocklet: { extraState: oldExtraState },
+      });
+    } catch (error) {
+      await this._rollback('install', meta.did, { extraState: oldExtraState });
+      throw error;
+    }
   }
 
   async _installComponentFromUpload({ rootDid, mountPoint, file, did, diffVersion, deleteSet, context }) {
@@ -1922,6 +1965,7 @@ class BlockletManager extends BaseBlockletManager {
       deployedFrom: `Upload by ${context.user.fullName}`,
       bundleSource: null,
       dynamic: true,
+      children: await parseChildrenFromMeta(meta, { ancestors: [{ mountPoint }] }),
     };
     const index = newBlocklet.children.findIndex((child) => child.meta.did === meta.did);
     if (index >= 0) {
@@ -1931,12 +1975,14 @@ class BlockletManager extends BaseBlockletManager {
     }
     await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild);
 
+    await this._downloadBlocklet(newBlocklet, oldBlocklet);
+
     await validateBlocklet(newBlocklet);
 
     return this._upgradeBlocklet({
       oldBlocklet,
       newBlocklet,
-      context,
+      context: { ...context, forceStartProcessIds: [getComponentProcessId(newChild, [newBlocklet])] },
     });
   }
 
@@ -2058,15 +2104,12 @@ class BlockletManager extends BaseBlockletManager {
     blocklets.forEach(run);
   }
 
-  async _getChildren(meta) {
+  async _getChildrenForInstallation(meta) {
     const staticChildren = await parseChildrenFromMeta(meta);
-    const dynamicChildren = await parseChildren(
-      await this._getDynamicChildrenFromSettings(meta.did, { skipDeleted: true }),
-      meta,
-      {
-        dynamic: true,
-      }
-    );
+    const dynamicChildren = await this._getDynamicChildrenFromSettings(meta.did, { skipDeleted: true });
+    for (const dynamicChild of dynamicChildren) {
+      dynamicChild.children = await parseChildrenFromMeta(dynamicChild.meta, { ancestors: [dynamicChild] });
+    }
     checkDuplicateComponents([...dynamicChildren, ...staticChildren]);
 
     return [...staticChildren, ...dynamicChildren];
@@ -2086,7 +2129,7 @@ class BlockletManager extends BaseBlockletManager {
 
     const oldExtraState = await states.blockletExtras.findOne({ did: meta.did });
 
-    const children = await this._getChildren(meta);
+    const children = await this._getChildrenForInstallation(meta);
     try {
       const blocklet = await states.blocklet.addBlocklet({
         meta,
@@ -2097,7 +2140,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await validateBlocklet(blocklet);
 
-      await this._setConfigs(did);
+      await this._setConfigsFromMeta(did);
 
       logger.info('blocklet added to database', { did: meta.did });
 
@@ -2183,7 +2226,7 @@ class BlockletManager extends BaseBlockletManager {
     newBlocklet.meta = ensureMeta(meta);
     newBlocklet.source = source;
     newBlocklet.deployedFrom = deployedFrom;
-    newBlocklet.children = await this._getChildren(meta);
+    newBlocklet.children = await this._getChildrenForInstallation(meta);
 
     await validateBlocklet(newBlocklet);
 
@@ -2379,7 +2422,7 @@ class BlockletManager extends BaseBlockletManager {
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall(b.env.appId, {
+        hooks.preInstall(b.env.processId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2394,10 +2437,10 @@ class BlockletManager extends BaseBlockletManager {
       blocklet = await this.ensureBlocklet(did);
 
       // post install
-      const postInstall = (b) =>
-        hooks.postInstall(b.env.appId, {
+      const postInstall = (b, { ancestors }) =>
+        hooks.postInstall(b.env.processId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+          env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
           appDir: b.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -2449,10 +2492,13 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _upgradeBlocklet({ newBlocklet, oldBlocklet, context }) {
+  async _upgradeBlocklet({ newBlocklet, oldBlocklet, context = {} }) {
     const { meta, source, deployedFrom, children } = newBlocklet;
     const { did, version, name } = meta;
 
+    // ids
+    context.skippedProcessIds = getSkippedProcessIds({ newBlocklet, oldBlocklet, context });
+
     const oldVersion = oldBlocklet.meta.version;
     const action = semver.gt(oldBlocklet.meta.version, version) ? 'downgrade' : 'upgrade';
     try {
@@ -2466,14 +2512,14 @@ class BlockletManager extends BaseBlockletManager {
 
       // update state
       await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
-      await this._setConfigs(did);
+      await this._setConfigsFromMeta(did);
 
       let blocklet = await this.ensureBlocklet(did);
 
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall(b.env.appId, {
+        hooks.preInstall(b.env.processId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2488,10 +2534,10 @@ class BlockletManager extends BaseBlockletManager {
       blocklet = await this.ensureBlocklet(did);
 
       // post install
-      const postInstall = (b) =>
-        hooks.postInstall(b.env.appId, {
+      const postInstall = (b, { ancestors }) =>
+        hooks.postInstall(b.env.processId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+          env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
           appDir: b.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -2500,13 +2546,13 @@ class BlockletManager extends BaseBlockletManager {
       await forEachBlocklet(blocklet, postInstall, { parallel: true });
 
       // run migrations
-      const runMigration = (b) => {
+      const runMigration = (b, { ancestors }) => {
         // BUG: 本身的定义是在执行 upgrade 操作时进行 migration，但是父 blocklet upgrade 时，子 blocklet 可能不需要 upgrade，就会导致子 blocklet 多走了一遍 migration 流程
         if (b.meta.did === did) {
           return runMigrationScripts({
             blocklet: b,
             appDir: b.env.appDir,
-            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
+            env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
             oldVersion,
             newVersion: version,
             did: b.meta.did,
@@ -2528,14 +2574,14 @@ class BlockletManager extends BaseBlockletManager {
 
       logger.info('updated blocklet for upgrading', { did, version, source, name });
 
+      const status =
+        oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
+      await states.blocklet.setBlockletStatus(did, status, { children: 'all' });
+
       // start new process
       if (oldBlocklet.status === BlockletStatus.running) {
         await this.start({ did }, context);
         logger.info('started blocklet for upgrading', { did, version });
-      } else {
-        const status =
-          oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-        await states.blocklet.setBlockletStatus(did, status, { children: 'all' });
       }
 
       blocklet = await this.ensureBlocklet(did, context);
@@ -2775,26 +2821,43 @@ class BlockletManager extends BaseBlockletManager {
       meta: { name, did },
     } = blocklet;
 
+    const oldComponentObj = {};
+    const downloadComponentIds = [];
+    const metaObj = {};
     const metas = [];
-    if (needBlockletDownload(blocklet)) {
-      metas.push(blocklet.meta);
-    }
 
-    const oldChildren = (oldBlocklet.children || []).reduce((o, x) => {
-      o[x.meta.did] = x;
-      return o;
-    }, {});
+    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,
+            });
+          }
 
-    for (const child of blocklet.children) {
-      const oldChild = oldChildren[child.meta.did];
-      if (needBlockletDownload(child, oldChild)) {
-        metas.push(child.meta);
+          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: metas.map((x) => ({ did: x.did })),
+      children: downloadComponentIds,
     });
     this.emit(BlockletEvents.statusChange, blocklet1);
 
@@ -2937,18 +3000,24 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
-  async _setConfigs(did, childDid) {
+  async _setConfigsFromMeta(did, childDid) {
     const blocklet = await states.blocklet.getBlocklet(did);
-    const { meta } = blocklet;
 
     if (!childDid) {
-      await states.blockletExtras.setConfigs(blocklet.meta.did, get(meta, 'environments', []));
-      for (const child of blocklet.children) {
-        await states.blockletExtras.setChildConfigs(blocklet.meta.did, child.meta.did, get(child.meta, 'environments'));
-      }
+      await forEachBlocklet(blocklet, async (b, { ancestors }) => {
+        await states.blockletExtras.setConfigs(
+          [...ancestors.map((x) => x.meta.did), b.meta.did],
+          get(b.meta, 'environments', [])
+        );
+      });
     } else {
       const child = blocklet.children.find((x) => x.meta.did === childDid);
-      await states.blockletExtras.setChildConfigs(blocklet.meta.did, child.meta.did, get(child.meta, 'environments'));
+      await forEachBlocklet(child, async (b, { ancestors }) => {
+        await states.blockletExtras.setConfigs(
+          [blocklet.meta.did, ...ancestors.map((x) => x.meta.did), b.meta.did],
+          get(b.meta, 'environments', [])
+        );
+      });
     }
   }