@abtnode/core 1.7.17 → 1.7.20

package/lib/blocklet/migration.js

@@ -53,7 +53,7 @@ async function runScripts({
     const { script: scriptPath } = pendingScripts[i];
     try {
       printInfo(`Migration script started: ${scriptPath}`);
-      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.appId, 'migration'].join(':'), {
+      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.processId, 'migration'].join(':'), {
         cwd: appDir,
         env: getSafeEnv(env),
         silent: false,

package/lib/migrations/1.7.20-blocklet-component.js

@@ -0,0 +1,41 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to delete realDid, realInterface and add componentId in db...');
+
+  const sites = await states.site.find({});
+
+  for (const site of sites) {
+    let changed = false;
+    for (const rule of site.rules || []) {
+      if (!rule.to) {
+        continue;
+      }
+
+      if (rule.to.type !== 'blocklet') {
+        continue;
+      }
+
+      if (rule.to.componentId) {
+        continue;
+      }
+
+      if (!rule.to.realDid || rule.to.did === rule.to.realDid) {
+        rule.to.componentId = rule.to.did;
+      } else {
+        rule.to.componentId = `${rule.to.did}/${rule.to.realDid}`;
+      }
+
+      delete rule.to.realDid;
+      delete rule.to.realInterfaceName;
+
+      changed = true;
+    }
+
+    if (changed) {
+      await states.site.update({ _id: site._id }, site);
+      printInfo(`site ${site.domain} has been updated`);
+    }
+  }
+};

package/lib/router/helper.js

@@ -334,7 +334,7 @@ const ensureWellknownRule = async (sites) => {
         .sort((a, b) => (a.from.pathPrefix.length > b.from.pathPrefix.length ? 1 : -1));
       if (blockletRules.length) {
         // get pathPrefix for blocklet-service
-        const rootBlockletRule = blockletRules.find((x) => x.to.did === x.to.realDid);
+        const rootBlockletRule = blockletRules.find((x) => x.to.did === x.to.componentId);
         const pathPrefix = joinUrl(rootBlockletRule?.from?.pathPrefix || '/', WELLKNOWN_SERVICE_PATH_PREFIX);
 
         // requests for /.well-known/service will stay in blocklet-service and never proxy back to blocklet

package/lib/router/index.js

@@ -206,7 +206,7 @@ Router.formatSites = (sites = []) => {
               type: ROUTING_RULE_TYPES.DAEMON,
               port: daemonRule.to.port,
               did: rule.to.did,
-              realDid: rule.to.realDid,
+              componentId: rule.to.componentId,
             },
           });
 

package/lib/router/manager.js

@@ -29,6 +29,7 @@ const {
   BLOCKLET_INTERFACE_TYPE_WEB,
   BlockletGroup,
 } = require('@blocklet/meta/lib/constants');
+const { forEachChildSync } = require('@blocklet/meta/lib/util');
 
 const {
   validateAddSite,
@@ -112,7 +113,7 @@ class RouterManager extends EventEmitter {
       for (const rule of newSite.rules) {
         this.fixRootBlockletRule(rule);
         checkPathPrefixInBlackList(rule.from.pathPrefix, dynamicPathBlackList);
-        rules.push(...(await this.getRules(rule)));
+        rules.push(...(await this.getRulesForMutation(rule)));
       }
     }
     newSite.rules = rules;
@@ -281,7 +282,7 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('addRoutingRule', { id, rule });
 
     // add child blocklet rules
-    for (const x of await this.getRules(rule)) {
+    for (const x of await this.getRulesForMutation(rule)) {
       await states.site.addRuleToSite(id, x);
     }
 
@@ -323,7 +324,7 @@ class RouterManager extends EventEmitter {
     // update rules
     const newRules = [
       ...dbSite.rules.filter((x) => (x.groupId && x.groupId !== rule.id) || x.id !== rule.id), // 有些路由没有 rule.groupId
-      ...(await this.getRules(rule)),
+      ...(await this.getRulesForMutation(rule)),
     ];
 
     const updateResult = await states.site.update({ _id: id }, { $set: { rules: newRules } });
@@ -604,8 +605,7 @@ class RouterManager extends EventEmitter {
     rule.from.pathPrefix = normalizePathPrefix(rule.from.pathPrefix);
     if (rule.to.type === ROUTING_RULE_TYPES.BLOCKLET) {
       rule.from.groupPathPrefix = rule.from.pathPrefix;
-      rule.to.realDid = rule.to.did;
-      rule.to.realInterfaceName = rule.to.interfaceName;
+      rule.to.componentId = rule.to.did;
     }
     if (rule.to.url) {
       rule.to.url = normalizeRedirectUrl(rule.to.url);
@@ -616,7 +616,7 @@ class RouterManager extends EventEmitter {
    * get all rules to be add or update to site from root rule
    * @param {*} rule
    */
-  async getRules(rule) {
+  async getRulesForMutation(rule) {
     if (rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET) {
       return [rule];
     }
@@ -626,23 +626,27 @@ class RouterManager extends EventEmitter {
 
     // get child rules
     const blocklet = await states.blocklet.getBlocklet(rule.to.did);
-    for (const child of blocklet.children || []) {
-      const { mountPoint } = child;
+    forEachChildSync(blocklet, (component, { id, ancestors }) => {
+      if (component.meta.group === BlockletGroup.gateway) {
+        return;
+      }
+
+      const { mountPoint } = component;
       if (!mountPoint) {
-        logger.error(`mountPoint of child ${child.meta.name} does not exist`);
+        logger.error(`mountPoint of child ${component.meta.name} does not exist`);
         // eslint-disable-next-line no-continue
-        continue;
+        return;
       }
 
-      const childWebInterface = findWebInterface(child);
+      const childWebInterface = findWebInterface(component);
       if (!childWebInterface) {
-        logger.error(`web interface of child ${child.meta.name} does not exist`);
+        logger.error(`web interface of child ${component.meta.name} does not exist`);
         // eslint-disable-next-line no-continue
-        continue;
+        return;
       }
 
-      const pathPrefix = path.join(rule.from.pathPrefix, mountPoint);
-      const isRootPath = pathPrefix === rule.from.pathPrefix;
+      const pathPrefix = path.join(rule.from.pathPrefix, ...ancestors.map((x) => x.mountPoint || ''), mountPoint);
+      const isRootPath = normalizePathPrefix(pathPrefix) === normalizePathPrefix(rule.from.pathPrefix);
       if (isRootPath) {
         occupied = true;
       }
@@ -657,17 +661,16 @@ class RouterManager extends EventEmitter {
         },
         to: {
           type: ROUTING_RULE_TYPES.BLOCKLET,
-          port: findInterfacePortByName(child, childWebInterface.name),
-          did: rule.to.did, // root blocklet did
-          interfaceName: rule.to.interfaceName, // root blocklet interface
-          realDid: child.meta.did, // child blocklet did
-          realInterfaceName: childWebInterface.name,
+          port: findInterfacePortByName(component, childWebInterface.name),
+          did: rule.to.did, // root component did
+          interfaceName: rule.to.interfaceName, // root component interface
+          componentId: id,
         },
         isProtected: isRootPath ? rule.isProtected : true,
       };
 
       rules.push(childRule);
-    }
+    });
 
     // get root rule
     if (!occupied && blocklet.meta.group !== BlockletGroup.gateway) {

package/lib/states/audit-log.js

@@ -110,7 +110,7 @@ const getLogContent = async (action, args, context, result, info, node) => {
     case 'deleteComponent':
       return `removed component ${args.did} from blocklet ${getBlockletInfo(result, info)}`;
     case 'configBlocklet':
-      return `updated following ${args.childDid ? `child ${args.childDid}` : ''} config for blocklet ${getBlockletInfo(result, info)}:\n${args.configs.map(x => `- ${x.key}: ${x.value}\n`)}`; // prettier-ignore
+      return `updated following config for blocklet ${getBlockletInfo(result, info)}:\n${args.configs.map(x => `- ${x.key}: ${x.value}\n`)}`; // prettier-ignore
     case 'upgradeBlocklet':
       return `upgraded blocklet ${getBlockletInfo(result, info)} to v${result.meta.version}`;
     case 'updateChildBlocklets':

package/lib/states/blocklet-extras.js

@@ -52,22 +52,14 @@ class BlockletExtrasState extends BaseState {
     methods.forEach((method) => {
       this.extras.forEach((extra) => {
         const fn = camelCase(`${method} ${extra.name}`); // getConfigs, getRules
-        this[fn] = this.generateExtraFn(method, extra);
-      });
-    });
-
-    const childMethods = ['get', 'set', 'del'];
-    childMethods.forEach((method) => {
-      this.childExtras.forEach((extra) => {
-        const childFn = camelCase(`${method} child ${extra.name}`); // getChildConfigs, getChildRules
-        this[childFn] = this.generateExtraChildFn(method, extra);
+        this[fn] = this.generateFn(method, extra);
       });
     });
   }
 
-  // generate extra functions
+  // generate functions
 
-  generateExtraFn(method, extra) {
+  generateFn(method, extra) {
     if (method === 'get') {
       return this.generateGetFn(extra);
     }
@@ -86,11 +78,20 @@ class BlockletExtrasState extends BaseState {
   }
 
   generateGetFn(extra) {
-    return async (did, path, defaultValue) => {
+    return async (dids, path, defaultValue) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { dek } = this.options;
       const { name, afterGet = noop('data') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      const data = afterGet({ data: item ? item[name] : item, did, dek });
+
+      let item = await this.asyncDB.findOne({ did: rootDid });
+      while (item && childDids.length) {
+        const did = childDids.shift();
+        item = (item.children || []).find((x) => x.did === did);
+      }
+
+      const data = afterGet({ data: item ? item[name] : item, did: rootDid, dek });
       if (!path) {
         return data;
       }
@@ -99,43 +100,71 @@ class BlockletExtrasState extends BaseState {
   }
 
   generateSetFn(extra) {
-    return async (did, data) => {
+    return async (dids, data) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { dek } = this.options;
       const { name, beforeSet = noop('cur') } = extra;
-      const item = await this.asyncDB.findOne({ did });
+      const exist = await this.asyncDB.findOne({ did: rootDid });
+
+      const item = exist || { did: rootDid };
+      let component = item;
+      while (childDids.length) {
+        const did = childDids.shift();
+        component.children = component.children || [];
+        let child = component.children.find((x) => x.did === did);
+        if (!child) {
+          child = { did };
+          component.children.push(child);
+        }
+        component = child;
+      }
 
-      if (!item) {
-        const insertData = {
-          did,
-          [name]: beforeSet({ old: undefined, cur: data, did, dek }),
-        };
-
-        const info = await this.asyncDB.insert(insertData);
-        logger.info('create info success');
-        return info[name];
+      const old = component[name];
+      const newData = beforeSet({ old, cur: data, did: rootDid, dek });
+      component[name] = newData;
+
+      if (!exist) {
+        await this.asyncDB.insert(item);
+        logger.info('create extra success', { name, dids });
+      } else {
+        await this.update(item._id, item);
+        logger.info('update extra success', { name, dids });
       }
 
-      const itemNameValue = item[name];
-      const updated = await this.update(item._id, {
-        $set: {
-          [name]: beforeSet({ old: itemNameValue, cur: data, did, dek }),
-        },
-      });
-      return updated[name];
+      return newData;
     };
   }
 
   generateDelFn(extra) {
-    return async (did) => {
+    return async (dids) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
+      const item = await this.asyncDB.findOne({ did: rootDid });
 
       if (!item) {
-        return item;
+        return null;
+      }
+
+      let component = item;
+      while (component && childDids.length) {
+        const did = childDids.shift();
+        component = (component.children || []).find((x) => x.did === did);
       }
 
-      await this.update(item._id, { $set: { [name]: null } });
-      return item[name];
+      if (!component) {
+        return null;
+      }
+
+      const updated = component[name];
+      component[name] = null;
+
+      await this.update(item._id, item);
+
+      return updated;
     };
   }
 
@@ -153,128 +182,6 @@ class BlockletExtrasState extends BaseState {
       return list;
     };
   }
-
-  // generate extra child functions
-
-  generateExtraChildFn(method, extra) {
-    if (method === 'get') {
-      return this.generateGetChildFn(extra);
-    }
-
-    if (method === 'set') {
-      return this.generateSetChildFn(extra);
-    }
-
-    if (method === 'del') {
-      return this.generateDelChildFn(extra);
-    }
-  }
-
-  generateGetChildFn(extra) {
-    return async (did, childDid) => {
-      const { dek } = this.options;
-      const { name, afterGet = noop('data') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-      return afterGet({ data: subItem ? subItem[name] : null, did, dek });
-    };
-  }
-
-  generateSetChildFn(extra) {
-    return async (did, childDid, data) => {
-      const { dek } = this.options;
-      const { name, beforeSet = noop('cur') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-
-      if (!item) {
-        const newData = beforeSet({ old: undefined, cur: data, did, dek });
-        const insertData = {
-          did,
-          children: [
-            {
-              did: childDid,
-              [name]: newData,
-            },
-          ],
-        };
-        await this.asyncDB.insert(insertData);
-
-        logger.info('create info success; insert child info success');
-
-        return newData;
-      }
-
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-
-      if (!subItem) {
-        const newData = beforeSet({ old: undefined, cur: data, did, dek });
-        await this.update(item._id, {
-          $addToSet: {
-            children: {
-              did: childDid,
-              [name]: newData,
-            },
-          },
-        });
-
-        logger.info('insert child info success');
-        return newData;
-      }
-
-      const newData = beforeSet({ old: subItem[name], cur: data, did, dek });
-
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          x[name] = newData;
-        }
-      });
-
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
-
-      return newData;
-    };
-  }
-
-  generateDelChildFn(extra) {
-    return async (did, childDid) => {
-      const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
-
-      if (!item) {
-        return null;
-      }
-
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-
-      if (!subItem) {
-        return null;
-      }
-
-      let updated = null;
-
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          updated = x[name];
-          x[name] = null;
-        }
-      });
-
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
-
-      return updated;
-    };
-  }
 }
 
 module.exports = BlockletExtrasState;

package/lib/states/blocklet.js

@@ -9,7 +9,7 @@ const detectPort = require('detect-port');
 const Lock = require('@abtnode/util/lib/lock');
 const security = require('@abtnode/util/lib/security');
 const { fixPerson, fixInterfaces } = require('@blocklet/meta/lib/fix');
-const { getDisplayName, forEachBlocklet } = require('@blocklet/meta/lib/util');
+const { getDisplayName, forEachBlocklet, forEachBlockletSync, forEachChildSync } = require('@blocklet/meta/lib/util');
 const {
   BlockletStatus,
   BlockletSource,
@@ -33,35 +33,31 @@ const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
 const formatBlocklet = (blocklet, phase, dek) => {
-  forEachBlocklet(
-    blocklet,
-    (b) => {
-      if (b.meta) {
-        fixPerson(b.meta);
-        fixInterfaces(b.meta);
-      }
+  forEachBlockletSync(blocklet, (b) => {
+    if (b.meta) {
+      fixPerson(b.meta);
+      fixInterfaces(b.meta);
+    }
 
-      b.children = b.children || [];
+    b.children = b.children || [];
+
+    if (!b.environments || !b.meta || !dek) {
+      return;
+    }
 
-      if (!b.environments || !b.meta || !dek) {
+    ['BLOCKLET_APP_SK'].forEach((key) => {
+      const env = b.environments.find((x) => x.key === key);
+      if (!env) {
         return;
       }
-
-      ['BLOCKLET_APP_SK'].forEach((key) => {
-        const env = b.environments.find((x) => x.key === key);
-        if (!env) {
-          return;
-        }
-        if (phase === 'onUpdate' && isHex(env.value) === true) {
-          env.value = security.encrypt(env.value, b.meta.did, dek);
-        }
-        if (phase === 'onRead' && isHex(env.value) === false) {
-          env.value = security.decrypt(env.value, b.meta.did, dek);
-        }
-      });
-    },
-    { sync: true }
-  );
+      if (phase === 'onUpdate' && isHex(env.value) === true) {
+        env.value = security.encrypt(env.value, b.meta.did, dek);
+      }
+      if (phase === 'onRead' && isHex(env.value) === false) {
+        env.value = security.decrypt(env.value, b.meta.did, dek);
+      }
+    });
+  });
 
   return blocklet;
 };
@@ -416,7 +412,7 @@ class BlockletState extends BaseState {
    * @param {BlockletStatus} status blocklet status
    *
    * children status only different with parent before blocklet installation
-   * @param {Array<{did}>} children
+   * @param {Array<componentId>} children
    */
   async setBlockletStatus(did, status, { children } = {}) {
     if (typeof status === 'undefined') {
@@ -440,44 +436,45 @@ class BlockletState extends BaseState {
     }
 
     // update children status
-    updates.children = doc.children.map((child) => {
+    forEachChildSync(doc, (child, { id }) => {
       if (children === 'all') {
         child.status = status;
-        return child;
+        return;
       }
 
       if (!children) {
-        if (![BlockletStatus.waiting, BlockletStatus.upgrading, BlockletStatus.installing].includes(status)) {
+        if (
+          ![
+            BlockletStatus.waiting,
+            BlockletStatus.upgrading,
+            BlockletStatus.installing,
+            BlockletStatus.starting,
+          ].includes(status)
+        ) {
           child.status = status;
         }
 
-        return child;
+        return;
       }
 
-      const inputChild = children.find((x) => x.did === child.meta.did);
-      if (inputChild) {
+      if (children.includes(id)) {
         child.status = status;
       }
-      return child;
     });
 
+    updates.children = doc.children;
     return this.updateBlocklet(did, updates);
   }
 
-  async fillChildrenPorts(children, { defaultPort = 0, oldChildren } = {}) {
+  async fillChildrenPorts(children, { defaultPort = 0, oldChildren, returnMaxPort } = {}) {
     let _maxPort = defaultPort;
     for (const child of children || []) {
       // generate ports
       const childMeta = child.meta;
+      const oldChild = (oldChildren || []).find((x) => x.meta.did === child.meta.did);
 
       // get skipOccupiedCheckPorts
-      let skipOccupiedCheckPorts = [];
-      if (Array.isArray(oldChildren)) {
-        const oldChild = oldChildren.find((x) => x.meta.did === child.meta.did);
-        if (oldChild) {
-          skipOccupiedCheckPorts = getExternalPortsFromMeta(oldChild.meta);
-        }
-      }
+      const skipOccupiedCheckPorts = oldChild ? getExternalPortsFromMeta(oldChild.meta) : [];
 
       const ports = await this.getBlockletPorts({
         interfaces: childMeta.interfaces || [],
@@ -486,22 +483,17 @@ class BlockletState extends BaseState {
       });
       _maxPort = getMaxPort(ports);
 
-      // fill old child's port to new child
-      if (Array.isArray(oldChildren)) {
-        const oldChild = oldChildren.find((x) => x.meta.did === child.meta.did);
-        if (oldChild && oldChild.ports) {
-          logger.info('Merge the previous ports to child blocklet', {
-            did: child.meta.did,
-            name: child.meta.name,
-            oldPorts: oldChild.ports,
-            ports,
-          });
-          Object.keys(ports).forEach((p) => {
-            ports[p] = oldChild.ports[p] || ports[p];
-          });
-          child.ports = ports;
-          continue; // eslint-disable-line
-        }
+      if (oldChild && oldChild.ports) {
+        // fill old child's port to new child
+        logger.info('Merge the previous ports to child blocklet', {
+          did: child.meta.did,
+          name: child.meta.name,
+          oldPorts: oldChild.ports,
+          ports,
+        });
+        Object.keys(ports).forEach((p) => {
+          ports[p] = oldChild.ports[p] || ports[p];
+        });
       }
 
       // assign a new port to child
@@ -509,6 +501,20 @@ class BlockletState extends BaseState {
       child.ports = ports;
     }
 
+    for (const child of children || []) {
+      const oldChild = (oldChildren || []).find((x) => x.meta.did === child.meta.did);
+
+      _maxPort = await this.fillChildrenPorts(child.children || [], {
+        defaultPort: _maxPort,
+        oldChildren: oldChild?.children,
+        returnMaxPort: true,
+      });
+    }
+
+    if (returnMaxPort) {
+      return _maxPort;
+    }
+
     return children;
   }
 
@@ -528,10 +534,6 @@ class BlockletState extends BaseState {
         throw new Error(`mountPoint is required when adding component ${getDisplayName(child, true)}`);
       }
 
-      if (meta.did === parent.meta.did) {
-        throw new Error('Cannot add self as a component');
-      }
-
       checkDuplicateComponents([child, ...newChildren]);
 
       newChildren.push({
@@ -543,6 +545,7 @@ class BlockletState extends BaseState {
         mode,
         dynamic: true,
         status: BlockletStatus.added,
+        children: child.children,
       });
 
       fixChildren(newChildren);