@abtnode/core 1.5.14 → 1.5.15

package/lib/blocklet/extras.js

@@ -26,7 +26,7 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
   // newConfig 为用户传的,也可以是从环境变量中去读的
   const uniqConfigs = uniqBy(newConfigs, (x) => x.key || x.name);
 
-  // `BLOCKLET_*` and `ABT_NODE_*`  vars can only be set by ABT Node Daemon with only a few exceptions.
+  // `BLOCKLET_*` and `ABT_NODE_*`  vars can only be set by Blocklet Server Daemon with only a few exceptions.
   const newConfig = uniqConfigs.filter((x) => {
     const key = x.key || x.name;
 

package/lib/blocklet/manager/disk.js

@@ -955,7 +955,7 @@ class BlockletManager extends BaseBlockletManager {
       return a.from.pathPrefix.length < b.from.pathPrefix ? 1 : -1;
     });
     const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
-    return getBlockletInterfaces({ blocklet, context, nodeInfo, sites: routingRules, nodeIp });
+    return getBlockletInterfaces({ blocklet, context, nodeInfo, routingRules, nodeIp });
   }
 
   async attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {

package/lib/blocklet/registry.js

@@ -3,7 +3,7 @@ const { BlockletGroup } = require('@blocklet/meta/lib/constants');
 const joinURL = require('url-join');
 const get = require('lodash/get');
 const pick = require('lodash/pick');
-const { BLOCKLET_REGISTRY_API_PREFIX } = require('@abtnode/constant');
+const { BLOCKLET_STORE_API_PREFIX } = require('@abtnode/constant');
 
 const { name } = require('../../package.json');
 
@@ -63,7 +63,7 @@ class BlockletRegistry {
 
     const url = joinURL(
       registryUrl || defaultRegistryUrl,
-      BLOCKLET_REGISTRY_API_PREFIX,
+      BLOCKLET_STORE_API_PREFIX,
       `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`
     );
 
@@ -109,7 +109,7 @@ class BlockletRegistry {
 
   async refreshBlocklets(context) {
     const registryUrl = await states.node.getBlockletRegistry();
-    const url = joinURL(registryUrl, BLOCKLET_REGISTRY_API_PREFIX, '/blocklets.json');
+    const url = joinURL(registryUrl, BLOCKLET_STORE_API_PREFIX, '/blocklets.json');
     try {
       let res = await request.get(url, {
         validateStatus: (status) => (status >= 200 && status < 300) || status === 304,
@@ -153,7 +153,7 @@ class BlockletRegistry {
 }
 
 BlockletRegistry.validateRegistryURL = async (registry) => {
-  const url = joinURL(registry, BLOCKLET_REGISTRY_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
+  const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
   try {
     const res = await request.get(url);
     if (Array.isArray(res.data)) {
@@ -170,7 +170,7 @@ BlockletRegistry.validateRegistryURL = async (registry) => {
 
 BlockletRegistry.getRegistryMeta = async (registry) => {
   try {
-    const url = joinURL(registry, BLOCKLET_REGISTRY_API_PREFIX, `/registry.json?__t__=${Date.now()}`);
+    const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/registry.json?__t__=${Date.now()}`);
     const { data } = await request.get(url);
 
     if (!data) {

package/lib/event.js

@@ -128,8 +128,8 @@ module.exports = ({
   const handleCLIEvent = (eventName) => {
     const [, status] = eventName.split('.');
     onEvent(eventName, {
-      title: `ABT Node ${status}`,
-      description: `ABT Node is ${status} successfully`,
+      title: `Blocklet Server ${status}`,
+      description: `Blocklet Server is ${status} successfully`,
       entityType: 'node',
       status: 'success',
     });

package/lib/migrations/1.5.15-site.js

@@ -0,0 +1,184 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
+
+const findBlocklet = (site, blocklets) => {
+  //  prefix = /
+  const rootRule = site.rules.find((x) => x.from.pathPrefix === '/' && x.to.type === 'blocklet');
+  if (rootRule) {
+    const blocklet = blocklets.find((x) => x.meta.did === rootRule.to.did);
+    if (blocklet) {
+      return blocklet;
+    }
+  }
+
+  for (const rule of site.rules) {
+    if (rule.to.type === 'blocklet') {
+      const blocklet = blocklets.find((x) => x.meta.did === rule.to.did);
+      if (blocklet) {
+        return blocklet;
+      }
+    }
+  }
+
+  return null;
+};
+
+const mergeSite = (newSite, oldSite) => {
+  const { domain, domainAliases = [], isProtected, rules, corsAllowedOrigins } = oldSite;
+
+  // merge domain
+  const domains = [
+    {
+      value: domain,
+      isProtected,
+    },
+    ...(domainAliases || []).map((x) => (typeof x === 'string' ? { value: x, isProtected: false } : x)),
+  ];
+  domains.forEach((x) => {
+    if (!newSite.domainAliases.some((y) => y.value === x.value)) {
+      newSite.domainAliases.push(x);
+    }
+  });
+
+  // merge cors
+  (corsAllowedOrigins || []).forEach((x) => {
+    if (!newSite.corsAllowedOrigins.includes(x)) {
+      newSite.corsAllowedOrigins.push(x);
+    }
+  });
+
+  // merge rules
+  (rules || []).forEach((x) => {
+    if (!newSite.rules.some((y) => normalizePathPrefix(y.from.pathPrefix) === normalizePathPrefix(x.from.pathPrefix))) {
+      newSite.rules.push(x);
+    }
+  });
+};
+
+module.exports = async ({ states, node, printInfo }) => {
+  printInfo('Migrate site to 2.0 version for router...\n');
+
+  const sites = await states.site.getSites();
+  const blocklets = await states.blocklet.getBlocklets();
+  printInfo(`Find blocklets: ${blocklets.length}`);
+
+  // blocklet site which ends with 888-888-888-888.ip.abtnet.io
+  const blockletSystemSites = [];
+
+  // custom site added by user
+  const customSites = [];
+
+  sites.forEach((site) => {
+    const { domain } = site;
+
+    // filter 3 default basic site
+    if (domain === '' || domain === '127.0.0.1' || domain === '*') {
+      return;
+    }
+
+    const blocklet = findBlocklet(site, blocklets);
+
+    if (domain.endsWith('888-888-888-888.ip.abtnet.io')) {
+      blockletSystemSites.push({
+        site,
+        blocklet,
+      });
+    } else {
+      customSites.push({
+        site,
+        blocklet,
+      });
+    }
+  });
+
+  printInfo(
+    `Find sites: ${sites.length}; blockletSystemSites: ${blockletSystemSites.length}; customSites: ${customSites.length}\n`
+  );
+  printInfo(`blockletSystemSites: ${blockletSystemSites.map((x) => x.site.domain).join(', ')}\n`);
+  printInfo(`customSites: ${customSites.map((x) => x.site.domain).join(', ')}\n`);
+
+  // generate new blocklet site for every installed blocklet
+  const newBlockletSites = {}; // <blockletDid>: <site>
+  for (const blocklet of blocklets) {
+    const domain = `${blocklet.meta.did}.blocklet-domain-group`;
+    newBlockletSites[blocklet.meta.did] = {
+      domain,
+      domainAliases: [],
+      isProtected: true,
+      rules: [],
+      corsAllowedOrigins: [],
+    };
+  }
+  printInfo(
+    `newBlockletSites: ${Object.values(newBlockletSites)
+      .map((x) => x.domain)
+      .join(', ')}\n`
+  );
+
+  printInfo('\n');
+  printInfo('Start merge blockletSystemSites to new sites');
+  for (const { site: oldSite, blocklet } of blockletSystemSites) {
+    // merge blockletSystemSite to new blocklet site
+    if (blocklet) {
+      const newSite = newBlockletSites[blocklet.meta.did];
+      mergeSite(newSite, oldSite);
+      printInfo(`Merge site from ${oldSite.domain} to ${newSite.domain}`);
+    }
+  }
+
+  printInfo('\n');
+  printInfo('Start merge customSites to new sites');
+  for (const { site: oldSite, blocklet } of customSites) {
+    // reserve custom site which not belong to any blocklet
+    if (!blocklet) {
+      printInfo(`Skip merge custom site: ${oldSite.domain}`);
+      oldSite.skip = true;
+      continue;
+    }
+    // merge custom site to new blocklet site
+    const newSite = newBlockletSites[blocklet.meta.did];
+    mergeSite(newSite, oldSite);
+    printInfo(`Merge site from ${oldSite.domain} to ${newSite.domain}`);
+  }
+
+  printInfo('\n');
+  printInfo('Start delete blockletSystemSites from db');
+  for (const { site: oldSite } of blockletSystemSites) {
+    if (oldSite.skip) {
+      printInfo(`Skip delete site from db: ${oldSite.domain}`);
+      continue;
+    }
+    // delete each blockletSystemSite
+    await states.site.remove({ _id: oldSite.id });
+    printInfo(`Delete site from db: ${oldSite.domain}`);
+  }
+
+  printInfo('\n');
+  printInfo('Start delete customSites from db');
+  for (const { site: oldSite } of customSites) {
+    if (oldSite.skip) {
+      printInfo(`Skip delete site from db: ${oldSite.domain}`);
+      continue;
+    }
+    // delete custom site which bind to a blocklet
+    await states.site.remove({ _id: oldSite.id });
+    printInfo(`Delete site from db: ${oldSite.domain}`);
+  }
+
+  // add new blocklet site to db
+  printInfo('\n');
+  printInfo('Start add new sites to db');
+  for (const site of Object.values(newBlockletSites)) {
+    await states.site.add(site);
+    printInfo(`Add site to db: ${site.domain}`);
+  }
+
+  await node.takeRoutingSnapshot({
+    message: 'Migrate site to 2.0 version for router',
+    dryRun: false,
+    handleRouting: false,
+  });
+  printInfo('\n');
+  printInfo('Take routing snapshot');
+};

package/lib/router/helper.js

@@ -28,11 +28,14 @@ const {
   CERTIFICATE_EXPIRES_WARNING_OFFSET,
   DEFAULT_DAEMON_PORT,
   DEFAULT_SERVICE_PATH,
+  SLOT_FOR_IP_DNS_SITE,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
   BLOCKLET_INTERFACE_TYPE_WEB,
   BLOCKLET_INTERFACE_WELLKNOWN,
+  BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
 } = require('@blocklet/meta/lib/constants');
 
 // eslint-disable-next-line global-require
@@ -48,15 +51,58 @@ const {
 } = require('../util');
 const { getServicesFromBlockletInterface } = require('../util/service');
 const getIpDnsDomainForBlocklet = require('../util/get-ip-dns-domain-for-blocklet');
+const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
 const Router = require('./index');
 const states = require('../states');
 
-const attachInterfaceUrls = async ({ sites = [], context }) => {
+/**
+ * replace 888-888-888-888 with accessible ip for domain
+ */
+const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) => {
+  let ip;
+  const ipRegex = /\d+[-.]\d+[-.]\d+[-.]\d+/;
+  const match = ipRegex.exec(context.hostname);
+  if (match) {
+    ip = match[0].replace(/\./g, '-');
+  } else if (node) {
+    const nodeInfo = await node.read();
+    const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+    if (nodeIp) {
+      ip = nodeIp;
+    }
+  }
+
+  const getDomainAliases = (site) =>
+    (site.domainAliases || []).map((domain) => {
+      if (!domain.value) {
+        return domain;
+      }
+      if (domain.value.includes(SLOT_FOR_IP_DNS_SITE) && ip) {
+        domain.value = domain.value.replace(SLOT_FOR_IP_DNS_SITE, ip);
+      }
+      return domain;
+    });
+
+  if (!Array.isArray(sites)) {
+    sites.domainAliases = getDomainAliases(sites);
+    return sites;
+  }
+
+  return sites.map((site) => {
+    site.domainAliases = getDomainAliases(site);
+
+    return site;
+  });
+};
+
+const attachInterfaceUrls = async ({ sites = [], context, node }) => {
   if (!sites) {
     return [];
   }
 
+  attachRuntimeDomainAliases({ sites, context, node });
+
   const getUrl = (rule, domain = '') => {
     const host = getBlockletHost({ domain, context });
     const prefix = trimSlash(rule.from.pathPrefix);
@@ -340,7 +386,7 @@ const ensureAuthService = async (sites = [], blockletManager) => {
       // we should only use rule.to.realInterfaceName, rule.to.interfaceName is for backward compatible
       const interfaceName = rule.to.realInterfaceName || rule.to.interfaceName;
       const { interfaces } = blocklet.meta;
-      const _interface = interfaces.find((x) => x.type === 'web' && x.name === interfaceName);
+      const _interface = interfaces.find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
       if (_interface) {
         rule.services = rule.services || [];
         rule.services.unshift(...getServicesFromBlockletInterface(_interface, { logError: logger.error }));
@@ -596,10 +642,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   /**
    * Add system sites for blocklet
    *
-   * @returns {boolean} if routing changed
+   * @returns {boolean} if routing state db changed
    */
   const _ensureBlockletSites = async (blocklet, sites, nodeInfo, context = {}) => {
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    const webInterface = (blocklet.meta.interfaces || []).find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    if (!webInterface) {
+      return false;
+    }
 
     const getPrefix = (str) => {
       if (!str || str === '*') {
@@ -608,68 +657,59 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return `/${str}`.replace(/^\/+/, '/');
     };
 
-    const changes = await Promise.all(
-      interfaces.map(async (x) => {
-        const domain = getIpDnsDomainForBlocklet(blocklet, x);
-        const pathPrefix = getPrefix(x.prefix);
-        const rule = {
-          from: { pathPrefix },
-          to: {
-            port: findInterfacePortByName(blocklet, x.name),
-            did: blocklet.meta.did,
-            type: ROUTING_RULE_TYPES.BLOCKLET,
-            interfaceName: x.name, // root blocklet interface
-          },
-          isProtected: true,
-        };
+    const domainGroup = `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}`;
+    const domain = getIpDnsDomainForBlocklet(blocklet, webInterface);
+    const pathPrefix = getPrefix(webInterface.prefix);
+    const rule = {
+      from: { pathPrefix },
+      to: {
+        port: findInterfacePortByName(blocklet, webInterface.name),
+        did: blocklet.meta.did,
+        type: ROUTING_RULE_TYPES.BLOCKLET,
+        interfaceName: webInterface.name, // root blocklet interface
+      },
+      isProtected: true,
+    };
 
-        let changed = false; // if state db changed
-
-        const exist = await states.site.findOne({ domain });
-        if (!exist) {
-          await routerManager.addRoutingSite(
-            {
-              site: {
-                domain,
-                isProtected: true,
-                // FIXME: tmp fix for https://github.com/ArcBlock/abt-node/issues/3526
-                corsAllowedOrigins: ['*'],
-                rules: [rule],
-              },
-              skipCheckDynamicBlacklist: true,
-            },
-            context
-          );
-          logger.info('add routing site', { site: domain });
+    const existSite = await states.site.findOne({ domain: domainGroup });
+    if (!existSite) {
+      await routerManager.addRoutingSite(
+        {
+          site: {
+            domain: domainGroup,
+            domainAliases: [{ value: domain, isProtected: true }],
+            isProtected: true,
+            rules: [rule],
+          },
+          skipCheckDynamicBlacklist: true,
+        },
+        context
+      );
+      logger.info('add routing site', { site: domain });
 
-          changed = true;
-        } else {
-          const existRule = (exist.rules || []).find((y) => get(y, 'from.pathPrefix') === pathPrefix);
-          if (existRule) {
-            await routerManager.updateRoutingRule({
-              id: exist.id,
-              rule: {
-                ...rule,
-                id: exist.id,
-              },
-              skipProtectedRuleChecking: true,
-            });
-            logger.info('update routing rule for site', { site: domain });
-          } else {
-            await routerManager.addRoutingRule({
-              id: exist.id,
-              rule,
-            });
-            logger.info('add routing rule for site', { site: domain });
-          }
-          changed = true;
-        }
+      return true;
+    }
 
-        return changed;
-      })
-    );
+    const existRule = (existSite.rules || []).find((y) => get(y, 'from.pathPrefix') === pathPrefix);
+    if (existRule) {
+      await routerManager.updateRoutingRule({
+        id: existSite.id,
+        rule: {
+          ...rule,
+          id: existRule.id,
+        },
+        skipProtectedRuleChecking: true,
+      });
+      logger.info('update routing rule for site', { site: domain });
+    } else {
+      await routerManager.addRoutingRule({
+        id: existSite.id,
+        rule,
+      });
+      logger.info('add routing rule for site', { site: domain });
+    }
 
-    return changes.some(Boolean);
+    return true;
   };
 
   /**
@@ -684,7 +724,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     }
 
     const tasks = (blocklet.meta.interfaces || [])
-      .filter((x) => x.name === BLOCKLET_INTERFACE_WELLKNOWN)
+      .filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WELLKNOWN)
       .map(async (x) => {
         const pathPrefix = normalizePathPrefix(x.prefix);
         if (!pathPrefix.startsWith(WELLKNOWN_PATH_PREFIX)) {
@@ -811,30 +851,15 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   };
 
   const _removeBlockletSites = async (blocklet, nodeInfo, context = {}) => {
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
-
-    const changes = await Promise.all(
-      interfaces.map(async (x) => {
-        let changed = false;
-
-        const domain = getIpDnsDomainForBlocklet(blocklet, x);
-
-        const site = await states.site.findOne({ domain });
-        if (
-          site &&
-          site.isProtected &&
-          (!site.domainAliases || !site.domainAliases.length) &&
-          (!site.rules || !site.rules.length)
-        ) {
-          await routerManager.deleteRoutingSite({ id: site.id }, context);
-          changed = true;
-        }
+    let changed = false;
 
-        return changed;
-      })
-    );
+    const site = await states.site.findOne({ domain: `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}` });
+    if (site) {
+      await routerManager.deleteRoutingSite({ id: site.id }, context);
+      changed = true;
+    }
 
-    return changes.some(Boolean);
+    return changed;
   };
 
   /**
@@ -854,8 +879,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return false;
     }
 
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
-    if (interfaces.length === 0) {
+    const hasWebInterface = (blocklet.meta.interfaces || []).some((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    if (!hasWebInterface) {
       return false;
     }
 
@@ -886,9 +911,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * @returns {boolean} if routing changed
    */
   const ensureBlockletCustomRouting = async (blocklet) => {
+    // Only one blocklet web interface can be declared since router 2.0
     const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
     const hasInterface = (name) => interfaces.some((x) => x.name === name);
-    const sites = await siteState.getRulesByDid(blocklet.meta.did);
+
+    const sites = await siteState.getSitesByBlocklet(blocklet.meta.did);
     let changed = false;
 
     for (const site of sites) {
@@ -1164,7 +1191,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       if (msg.length < 5) {
         throw new Error('Message cannot be less than 5 characters');
       }
-      if (msg.length > 100) {
+      if (msg.length > 150) {
         throw new Error('Message cannot exceed 100 characters');
       }
     }
@@ -1216,12 +1243,17 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return attachInterfaceUrls({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
+      node: nodeState,
     });
   };
 
   const getSnapshotSites = async ({ hash }, context = {}, { withDefaultCors = true } = {}) => {
     const sites = await routingSnapshot.readSnapshotSites(hash);
-    return attachInterfaceUrls({ sites: await ensureLatestInfo(sites, { withDefaultCors }), context });
+    return attachInterfaceUrls({
+      sites: await ensureLatestInfo(sites, { withDefaultCors }),
+      context,
+      node: nodeState,
+    });
   };
 
   const getCertificates = async () => {
@@ -1262,7 +1294,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         logger.info('send certificate expire notification', { domain: cert.domain });
         notification.create({
           title: 'SSL Certificate Expired',
-          description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in ABT Node`,
+          description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in Blocklet Server`,
           severity: 'error',
           entityType: 'certificate',
           entityId: cert._id, // eslint-disable-line no-underscore-dangle
@@ -1276,7 +1308,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             cert.domain
           } will expire in ${expireInDays} days (on ${new Date(
             cert.validTo
-          ).toLocaleString()}), please remember to update it in ABT Node`,
+          ).toLocaleString()}), please remember to update it in Blocklet Server`,
           severity: 'warning',
           entityType: 'certificate',
           entityId: cert._id, // eslint-disable-line no-underscore-dangle

package/lib/router/index.js

@@ -6,6 +6,7 @@ const {
   ROUTING_RULE_TYPES,
   DEFAULT_DASHBOARD_DOMAIN,
   BLOCKLET_PROXY_PATH_PREFIX,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
 const { BLOCKLET_UI_INTERFACES } = require('@blocklet/meta/lib/constants');
 const { pick } = require('lodash');
@@ -26,7 +27,11 @@ const expandSites = (sites = []) => {
     });
 
     delete site.domainAliases;
-    result.push(site);
+
+    // skip site if domain is BLOCKLET_SITE_GROUP
+    if (!site.domain.endsWith(BLOCKLET_SITE_GROUP_SUFFIX)) {
+      result.push(site);
+    }
   });
 
   const defaultSite = result.find((site) => site.domain === DOMAIN_FOR_DEFAULT_SITE);
@@ -45,7 +50,10 @@ const mergeAllowedOrigins = (domain, allowedOrigins) => {
     origins.push(domain);
   }
 
-  return origins;
+  // skip site if domain is BLOCKLET_SITE_GROUP
+  const res = origins.filter((x) => !x.endsWith(BLOCKLET_SITE_GROUP_SUFFIX));
+
+  return res;
 };
 
 const getRoutingTable = ({ sites, nodeInfo }) => {

package/lib/router/manager.js

@@ -121,7 +121,7 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('addRoutingSite', { site: newSite });
 
     const result = await states.site.add(newSite);
-    await attachInterfaceUrls({ sites: result, context });
+    await attachInterfaceUrls({ sites: result, context, node: states.node });
 
     this.emit('router.site.created', result);
     return result;
@@ -181,7 +181,7 @@ class RouterManager extends EventEmitter {
     this.emit('router.site.updated', params.id);
 
     const dbSite = await states.site.findOne({ _id: params.id });
-    await attachInterfaceUrls({ sites: dbSite, context });
+    await attachInterfaceUrls({ sites: dbSite, context, node: states.node });
     return dbSite;
   }
 
@@ -207,7 +207,7 @@ class RouterManager extends EventEmitter {
     logger.debug('add domain alias update result', { id, updateResult, domainAlias });
 
     const newSite = await states.site.findOne({ _id: id });
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     return newSite;
   }
@@ -230,7 +230,7 @@ class RouterManager extends EventEmitter {
     const updateResult = await states.site.update({ _id: id }, { $set: { domainAliases: dbSite.domainAliases } });
     logger.debug('remove domain alias update result', { id, updateResult, domainAlias });
 
-    await attachInterfaceUrls({ sites: dbSite, context });
+    await attachInterfaceUrls({ sites: dbSite, context, node: states.node });
 
     return dbSite;
   }
@@ -265,7 +265,7 @@ class RouterManager extends EventEmitter {
     }
 
     const newSite = await states.site.findOne({ _id: id });
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.created', newSite);
     return newSite;
@@ -306,7 +306,7 @@ class RouterManager extends EventEmitter {
     logger.info('update result', { updateResult });
     const newSite = await states.site.findOne({ _id: id });
 
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.updated', newSite);
 
@@ -335,7 +335,7 @@ class RouterManager extends EventEmitter {
     logger.info('router.rule.removed', { id, ruleId });
     const newSite = await states.site.findOne({ _id: id });
 
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.removed', newSite);
     return newSite;

package/lib/states/site.js

@@ -33,7 +33,7 @@ class SiteState extends BaseState {
     return SiteState.renameIdFiledName(result);
   }
 
-  async getRulesByDid(did) {
+  async getSitesByBlocklet(did) {
     const rules = await this.asyncDB.find({ 'rules.to.did': did });
     return SiteState.renameIdFiledName(rules);
   }

package/lib/team/manager.js

@@ -190,7 +190,7 @@ class TeamManager extends EventEmitter {
     // first getRBAC after blocklet added
     if (!this.cache[did].rbac) {
       if (this.isNodeTeam(did)) {
-        throw new Error('ABT Node rbac instance has not been initialized');
+        throw new Error('Blocklet Server rbac instance has not been initialized');
       }
 
       // FIXME: cross process lock

package/lib/util/default-node-config.js

@@ -1,7 +1,7 @@
 const {
   NODE_REGISTER_URL,
-  BLOCKLET_REGISTRY_URL,
-  BLOCKLET_REGISTRY_URL_DEV,
+  BLOCKLET_STORE_URL,
+  BLOCKLET_STORE_URL_DEV,
   WEB_WALLET_URL,
   NODE_PACKAGE_NAME,
   NODE_COMMAND_NAME,
@@ -23,18 +23,18 @@ const defaultNodeConfigs = {
   blockletRegistryList: {
     getDefaultValue: () => [
       {
-        name: 'Official Registry',
+        name: 'Official Store',
         description: 'ArcBlock official blocklet registry',
-        url: BLOCKLET_REGISTRY_URL,
+        url: BLOCKLET_STORE_URL,
         logoUrl: '/logo.png',
         maintainer: 'arcblock',
         selected: true,
         protected: true,
       },
       {
-        name: 'Dev Registry',
+        name: 'Dev Store',
         description: 'ArcBlock dev registry that contains demo and example blocklets',
-        url: BLOCKLET_REGISTRY_URL_DEV,
+        url: BLOCKLET_STORE_URL_DEV,
         maintainer: 'arcblock',
         logoUrl: '/logo.png',
         selected: false,

package/lib/util/index.js

@@ -29,7 +29,9 @@ const {
   ROUTING_RULE_TYPES,
   SLOT_FOR_IP_DNS_SITE,
   DEFAULT_IP_DNS_DOMAIN_SUFFIX,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
+const { BLOCKLET_INTERFACE_TYPE_WEB } = require('@blocklet/meta/lib/constants');
 
 const DEFAULT_WELLKNOWN_PORT = 8088;
 
@@ -137,7 +139,7 @@ const getAuthConfig = (rule, blocklet) => {
   // find interface in meta
   const interfaceName = rule.to.realInterfaceName;
   const { interfaces } = _blocklet.meta;
-  const _interface = interfaces.find((x) => x.type === 'web' && x.name === interfaceName);
+  const _interface = interfaces.find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
 
   if (!_interface) {
     return null;
@@ -155,13 +157,14 @@ const getAuthConfig = (rule, blocklet) => {
   return auth.config;
 };
 
-const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context = {}, blocklet, nodeIp }) => {
+const getBlockletBaseUrls = ({ routingEnabled = false, port, rules = [], context = {}, blocklet, nodeIp }) => {
   let baseUrls = [];
 
-  if (routingEnabled && Array.isArray(sites) && sites.length > 0) {
-    baseUrls = sites
-      .map((site) => {
-        const host = getBlockletHost({ domain: site.from.domain, context, nodeIp });
+  if (routingEnabled && Array.isArray(rules) && rules.length > 0) {
+    baseUrls = rules
+      .filter((rule) => !(rule.from.domain || '').endsWith(BLOCKLET_SITE_GROUP_SUFFIX))
+      .map((rule) => {
+        const host = getBlockletHost({ domain: rule.from.domain, context, nodeIp });
         if (host) {
           let protocol = 'http'; // TODO: 这里固定为 http, 因为判断 url 是不是 https 和证书相关，这里实现的话比较复杂
           if (host.includes(DEFAULT_IP_DNS_DOMAIN_SUFFIX)) {
@@ -169,10 +172,10 @@ const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context
           }
 
           return {
-            ruleId: site.id,
-            baseUrl: `${protocol}://${host}/${trimSlash(site.from.pathPrefix)}`,
-            interfaceName: get(site, 'to.interfaceName', ''),
-            authConfig: getAuthConfig(site, blocklet),
+            ruleId: rule.id,
+            baseUrl: `${protocol}://${host}/${trimSlash(rule.from.pathPrefix)}`,
+            interfaceName: get(rule, 'to.interfaceName', ''),
+            authConfig: getAuthConfig(rule, blocklet),
           };
         }
 
@@ -188,7 +191,7 @@ const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context
   return baseUrls;
 };
 
-const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) => {
+const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, nodeIp }) => {
   const interfaces = [];
   (blocklet.meta.interfaces || []).forEach((x) => {
     if (x.port && x.port.external) {
@@ -196,7 +199,7 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) =
       const baseUrls = getBlockletBaseUrls({
         routingEnabled: false,
         port: x.port.external,
-        sites: [],
+        rules: [],
         context,
       });
       baseUrls.forEach(({ baseUrl }) => interfaces.push({ type: x.type, name: x.name, url: baseUrl }));
@@ -206,9 +209,11 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) =
       const baseUrls = getBlockletBaseUrls({
         routingEnabled: isRoutingEnabled(nodeInfo.routing),
         port,
-        sites: (sites || []).filter((r) => {
+        rules: (routingRules || []).filter((r) => {
           return (
             // don't show wellknown interface
+            r.to.type !== ROUTING_RULE_TYPES.GENERAL_PROXY &&
+            // LEGACY don't show wellknown interface
             r.to.interfaceName !== BLOCKLET_INTERFACE_WELLKNOWN &&
             // don't show child blocklet interface
             (!r.from.groupPathPrefix || r.from.pathPrefix === r.from.groupPathPrefix)
@@ -329,7 +334,7 @@ const getDataDirs = (dataDir) => ({
   services: path.join(dataDir, 'services'),
 });
 
-// Ensure data dir for ABT Node exists
+// Ensure data dir for Blocklet Server exists
 const ensureDataDirs = (dataDir) => {
   try {
     logger.info('ensure data dir', { dataDir });

package/lib/util/ready.js

@@ -29,19 +29,19 @@ const createStateReadyHandler =
             // eslint-disable-next-line no-underscore-dangle
             await states.node.remove({ _id: state._id });
             console.error('\n\x1b[31m======================================================');
-            console.error(`Data dir: ${options.dataDir} is used by another ABT Node instance, abort!`);
-            console.error('Sharing data dir between ABT Node instances may break things!');
+            console.error(`Data dir: ${options.dataDir} is used by another Blocklet Server instance, abort!`);
+            console.error('Sharing data dir between Blocklet Server instances may break things!');
             console.error('======================================================\x1b[0m');
             console.log('\nIf you intend to use this dir:');
-            console.log(`  1. Stop ABT Node by ${chalk.cyan('abtnode stop --force')}`);
+            console.log(`  1. Stop Blocklet Server by ${chalk.cyan('abtnode stop --force')}`);
             console.log(`  2. Clear data dir by ${chalk.cyan(`rm -r ${options.dataDir}`)}`);
-            console.log(`  3. Reinitialize and start ABT Node`);
+            console.log('  3. Reinitialize and start Blocklet Server');
             process.exit(1);
           }
         }
       })
       .catch((err) => {
-        console.error('Can not ready node state on ABT Node start:', err.message);
+        console.error('Can not ready node state on Blocklet Server start:', err.message);
         process.exit(1);
       });
   };

package/lib/util/upgrade.js

@@ -36,15 +36,15 @@ const checkNewVersion = async (params, context) => {
       const latestVersion = versions[0].version;
       if (semver.gt(latestVersion, info.version)) {
         // if (semver.gte(latestVersion, info.version)) {
-        logger.info('New version found for abt node', {
+        logger.info('New version found for Blocklet Server', {
           latestVersion,
           currentVersion: info.version,
           nextVersion: info.nextVersion,
         });
         await states.node.updateNodeInfo({ nextVersion: latestVersion });
         await states.notification.create({
-          title: 'ABT Node upgrade available',
-          description: 'A new and improved version of ABT Node is now available',
+          title: 'Blocklet Server upgrade available',
+          description: 'A new and improved version of blocklet server is now available',
           entityType: 'node',
           severity: 'info',
           sticky: true,
@@ -57,7 +57,7 @@ const checkNewVersion = async (params, context) => {
 
     return '';
   } catch (err) {
-    logger.error('Failed to check new version for abt node', { error: err });
+    logger.error('Failed to check new version for Blocklet Server', { error: err });
   }
 
   return '';

package/lib/validators/router.js

@@ -83,6 +83,13 @@ const corsSchema = Joi.array()
 
 const ruleJoiSchema = Joi.object(ruleSchema);
 
+const addDomainAlias = Joi.alternatives()
+  .try(
+    Joi.string().domain({ minDomainSegments: 1, tlds: false }),
+    Joi.string().regex(WILDCARD_DOMAIN_REGEX) // 这种其实是一种特殊的 tld
+  )
+  .required();
+
 const addSiteSchema = Joi.object({
   domain: Joi.alternatives()
     .try(
@@ -92,6 +99,12 @@ const addSiteSchema = Joi.object({
     )
     .required()
     .messages(domainMessages),
+  domainAliases: Joi.array().items(
+    Joi.object({
+      value: addDomainAlias,
+      isProtected: Joi.boolean(),
+    })
+  ),
   isProtected: Joi.boolean(),
   rules: Joi.array().items(ruleJoiSchema),
   corsAllowedOrigins: corsSchema,
@@ -109,13 +122,6 @@ const updateSite = Joi.object({
     .messages(domainMessages),
 });
 
-const addDomainAlias = Joi.alternatives()
-  .try(
-    Joi.string().domain({ minDomainSegments: 1, tlds: false }),
-    Joi.string().regex(WILDCARD_DOMAIN_REGEX) // 这种其实是一种特殊的 tld
-  )
-  .required();
-
 const addRuleSchema = Joi.object({
   id: Joi.string().required(),
   rule: ruleJoiSchema,

package/lib/webhook/index.js

@@ -15,7 +15,7 @@ const getSlackUrlInfo = (actionPath = '/notifications', urls) => {
       type: 'section',
       text: {
         type: 'mrkdwn',
-        text: 'Use the following links to visit the blocklet detail on your ABT Node dashboard:',
+        text: 'Use the following links to visit the blocklet detail on your Blocklet Server dashboard:',
       },
     });
   } else {
@@ -23,7 +23,7 @@ const getSlackUrlInfo = (actionPath = '/notifications', urls) => {
       type: 'section',
       text: {
         type: 'mrkdwn',
-        text: 'Use the following links to visit your ABT Node dashboard:',
+        text: 'Use the following links to visit your Blocklet Server dashboard:',
       },
     });
   }

package/lib/webhook/sender/slack/index.js

@@ -56,7 +56,7 @@ class SlackSender extends BaseSender {
 
       await webhook.send({
         ...messageTypes[type],
-        username: 'ABT Node',
+        username: 'Blocklet Server',
         icon_url: 'https://releases.arcblockio.cn/arcblock.png',
       });
     } catch (error) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.14",
+  "version": "1.5.15",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,26 +19,26 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/constant": "1.5.14",
-    "@abtnode/cron": "1.5.14",
-    "@abtnode/logger": "1.5.14",
-    "@abtnode/queue": "1.5.14",
-    "@abtnode/rbac": "1.5.14",
-    "@abtnode/router-provider": "1.5.14",
-    "@abtnode/static-server": "1.5.14",
-    "@abtnode/timemachine": "1.5.14",
-    "@abtnode/util": "1.5.14",
-    "@arcblock/did": "^1.13.60",
-    "@arcblock/event-hub": "1.13.60",
+    "@abtnode/constant": "1.5.15",
+    "@abtnode/cron": "1.5.15",
+    "@abtnode/logger": "1.5.15",
+    "@abtnode/queue": "1.5.15",
+    "@abtnode/rbac": "1.5.15",
+    "@abtnode/router-provider": "1.5.15",
+    "@abtnode/static-server": "1.5.15",
+    "@abtnode/timemachine": "1.5.15",
+    "@abtnode/util": "1.5.15",
+    "@arcblock/did": "^1.13.61",
+    "@arcblock/event-hub": "1.13.61",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "^1.13.60",
-    "@blocklet/meta": "1.5.14",
+    "@arcblock/vc": "^1.13.61",
+    "@blocklet/meta": "1.5.15",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
-    "@ocap/mcrypto": "^1.13.60",
-    "@ocap/util": "^1.13.60",
-    "@ocap/wallet": "^1.13.60",
+    "@ocap/mcrypto": "^1.13.61",
+    "@ocap/util": "^1.13.61",
+    "@ocap/wallet": "^1.13.61",
     "@slack/webhook": "^5.0.3",
     "axios": "^0.21.4",
     "axon": "^2.0.3",
@@ -73,5 +73,5 @@
     "express": "^4.17.1",
     "jest": "^27.3.1"
   },
-  "gitHead": "9759378266a2d13a5083398490c7baed39e19f31"
+  "gitHead": "dae9d209af2576152ad85f13a2fc4855969608ed"
 }