@abtnode/core 1.4.10 → 1.4.14

package/lib/blocklet/manager/disk.js

@@ -8,6 +8,7 @@ const capitalize = require('lodash/capitalize');
 const diff = require('deep-diff');
 const { Throttle } = require('stream-throttle');
 const { isValid: isValidDid } = require('@arcblock/did');
+const { verifyPresentation } = require('@arcblock/vc');
 const { toBase58 } = require('@ocap/util');
 const { fromSecretKey } = require('@ocap/wallet');
 
@@ -15,6 +16,8 @@ const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
 const hashFiles = require('@abtnode/util/lib/hash-files');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
+const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
+const { BLOCKLET_PURCHASE_NFT_TYPE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const { isFreeBlocklet } = require('@blocklet/meta/lib/payment');
@@ -31,6 +34,7 @@ const {
   fromBlockletSource,
 } = require('@blocklet/meta/lib/constants');
 const util = require('../../util');
+const getAccessibleExternalNodeIp = require('../../util/get-accessible-external-node-ip');
 const {
   forEachBlocklet,
   getBlockletDirs,
@@ -57,6 +61,7 @@ const {
   getRuntimeInfo,
   mergeMeta,
   getUpdateMetaList,
+  getRuntimeEnvironments,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BlockletRegistry = require('../registry');
@@ -135,45 +140,46 @@ class BlockletManager extends BaseBlockletManager {
    */
   async install(params, context) {
     logger.debug('install blocklet', { params, context });
-    if (params.installId) {
-      const { installId, sync } = params;
-      return this._installFromId({ installId, sync }, context);
+    if (params.url) {
+      return this._installFromUrl({ url: params.url, sync: params.sync }, context);
     }
+
     if (params.file) {
       const { file, did, diffVersion, deleteSet } = params;
       return this._installFromUpload({ file, did, diffVersion, deleteSet, context });
     }
 
     if (params.did) {
-      return this._installFromRegistry(params.did, context);
+      return this._installFromRegistry({ did: params.did }, context);
     }
 
     throw new Error('Can only install blocklet from url/file/did');
   }
 
   // eslint-disable-next-line no-unused-vars
-  async installFromUrl({ url }, context) {
-    logger.info('Install from url', { from: url });
+  async getMetaFromUrl({ url }, context) {
+    const meta = await getBlockletMetaFromUrl(url);
 
-    try {
-      const meta = await getBlockletMetaFromUrl(url);
+    return meta;
+  }
 
-      const { id: installId } = await this.session.start({
-        meta,
-        metaSource: url,
-      });
+  async installBlockletFromVc({ vcPresentation, challenge }, context) {
+    logger.info('Install from vc');
+    const vc = getVcFromPresentation(vcPresentation);
 
-      const exist = await this.state.getBlocklet(meta.did);
+    // FIXME: 这里的 trustedIssuers 相当于相信任何 VC，需要想更安全的方法
+    verifyPresentation({ presentation: vcPresentation, trustedIssuers: [get(vc, 'issuer.id')], challenge });
 
-      return {
-        installId,
-        meta,
-        existingMeta: exist ? exist.meta : null,
-      };
-    } catch (error) {
-      logger.error('Install from url error', { url, error });
-      throw error;
+    if (!vc.type.includes(BLOCKLET_PURCHASE_NFT_TYPE)) {
+      throw new Error(`Expect ${BLOCKLET_PURCHASE_NFT_TYPE} VC type`);
     }
+
+    const blockletUrl = get(vc, 'credentialSubject.purchased.blocklet.url');
+    const urlObject = new URL(blockletUrl);
+    const did = get(vc, 'credentialSubject.purchased.blocklet.id');
+    const registry = urlObject.origin;
+
+    return this._installFromRegistry({ did, registry }, { ...context, blockletPurchaseVerified: true });
   }
 
   async start({ did, checkHealthImmediately = false, throwOnError }, context) {
@@ -216,7 +222,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preStart(b, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments },
+            env: getRuntimeEnvironments(b, nodeEnvironments),
             did, // root blocklet did,
             progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
@@ -288,7 +294,7 @@ class BlockletManager extends BaseBlockletManager {
         hooks.preStop({
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments },
+          env: getRuntimeEnvironments(b, nodeEnvironments),
           did, // root blocklet did
           notification: this.notification,
           context,
@@ -361,7 +367,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preUninstall({
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments },
+            env: getRuntimeEnvironments(b, nodeEnvironments),
             did, // root blocklet did
             notification: this.notification,
             context,
@@ -472,8 +478,12 @@ class BlockletManager extends BaseBlockletManager {
       if (x.key === 'BLOCKLET_APP_SK') {
         try {
           fromSecretKey(x.value);
-        } catch (err) {
-          throw new Error('Invalid custom blocklet secret key');
+        } catch {
+          try {
+            fromSecretKey(x.value, 'eth');
+          } catch {
+            throw new Error('Invalid custom blocklet secret key');
+          }
         }
       }
 
@@ -483,13 +493,13 @@ class BlockletManager extends BaseBlockletManager {
         }
       }
 
-      blocklet.userEnvironments[x.key] = x.value;
+      blocklet.configObj[x.key] = x.value;
     });
     await hooks.preConfig({
       appDir: blocklet.env.appDir,
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
       exitOnError: true,
-      env: { ...nodeEnvironments, ...blocklet.systemEnvironments, ...blocklet.userEnvironments },
+      env: { ...getRuntimeEnvironments(blocklet, nodeEnvironments), ...blocklet.configObj },
       notification: this.notification,
       did,
       context,
@@ -891,7 +901,8 @@ class BlockletManager extends BaseBlockletManager {
         // Put shorter url first
         return a.from.pathPrefix.length < b.from.pathPrefix ? 1 : -1;
       });
-      blocklet.interfaces = getBlockletInterfaces({ blocklet, context, nodeInfo, sites: routingRules });
+      const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+      blocklet.interfaces = getBlockletInterfaces({ blocklet, context, nodeInfo, sites: routingRules, nodeIp });
 
       try {
         const { appId } = blocklet.meta.group === BlockletGroup.gateway ? blocklet.children[0].env : blocklet.env;
@@ -1116,12 +1127,12 @@ class BlockletManager extends BaseBlockletManager {
     const nodeInfo = await this.node.read();
 
     const rootSystemEnvironments = getRootSystemEnvironments(blockletWithEnv, nodeInfo);
-    const rootUserEnvironment = blockletWithEnv.userEnvironments;
-    const overwrittenEnvironments = getOverwrittenEnvironments(blockletWithEnv);
+    const rootConfig = blockletWithEnv.configObj;
+    const overwrittenEnvironments = getOverwrittenEnvironments(blockletWithEnv, nodeInfo);
 
     // fill environments to blocklet and blocklet.children
     blocklet.environments = formatEnvironments({
-      ...rootUserEnvironment,
+      ...rootConfig,
       ...getSystemEnvironments(blockletWithEnv),
       ...rootSystemEnvironments,
       ...overwrittenEnvironments,
@@ -1130,11 +1141,12 @@ class BlockletManager extends BaseBlockletManager {
     for (const child of blocklet.children) {
       const childWithEnv = blockletWithEnv.children.find((x) => x.meta.did === child.meta.did);
       if (childWithEnv) {
+        const childConfig = childWithEnv.configObj;
         child.environments = formatEnvironments({
-          ...childWithEnv.userEnvironments,
-          ...rootUserEnvironment, // FIXME: use options or hooks to make merge logic flexible
-          ...getSystemEnvironments(childWithEnv),
-          ...rootSystemEnvironments,
+          ...childConfig, // custom env of child blocklet
+          ...rootConfig, // // custom env of root blocklet FIXME: use options or hooks to make merge logic flexible
+          ...getSystemEnvironments(childWithEnv), // system env of child blocklet
+          ...rootSystemEnvironments, // system env of root blocklet
           ...overwrittenEnvironments,
         });
       }
@@ -1152,15 +1164,15 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _installFromRegistry(did, context) {
+  async _installFromRegistry({ did, registry }, context) {
     logger.debug('start install blocklet', { did });
     if (!isValidDid(did)) {
       throw new Error('Blocklet did is invalid');
     }
 
-    const registryUrl = await states.node.getBlockletRegistry();
+    const registryUrl = registry || (await states.node.getBlockletRegistry());
     const info = await BlockletRegistry.getRegistryMeta(registryUrl);
-    const blocklet = await this.registry.getBlocklet(did);
+    const blocklet = await this.registry.getBlocklet(did, registryUrl);
     if (!blocklet) {
       throw new Error('Can not install blocklet that not found in registry');
     }
@@ -1183,15 +1195,13 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
-  async _installFromId({ installId: id, sync }, context) {
-    logger.debug('start install blocklet', { installId: id });
-    if (!id) {
-      throw new Error('Install id should not be empty');
-    }
+  async _installFromUrl({ url, sync }, context) {
+    logger.debug('start install blocklet', { url });
+
+    const meta = await getBlockletMetaFromUrl(url);
 
-    const { meta, metaSource } = await this.session.end(id);
     if (!meta) {
-      throw new Error(`Can not install blocklet that not found by installId: ${id}`);
+      throw new Error(`Can not install blocklet that not found by url: ${url}`);
     }
 
     // upgrade
@@ -1200,7 +1210,7 @@ class BlockletManager extends BaseBlockletManager {
       return this._upgrade({
         meta,
         source: BlockletSource.url,
-        deployedFrom: metaSource,
+        deployedFrom: url,
         sync,
         context,
       });
@@ -1210,7 +1220,7 @@ class BlockletManager extends BaseBlockletManager {
     return this._install({
       meta,
       source: BlockletSource.url,
-      deployedFrom: metaSource,
+      deployedFrom: url,
       sync,
       context,
     });
@@ -1738,7 +1748,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments },
+          env: getRuntimeEnvironments(b, nodeEnvironments),
           appDir: blocklet.env.appDir,
           did, // root blocklet did
           notification: this.notification,
@@ -1824,7 +1834,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments },
+          env: getRuntimeEnvironments(b, nodeEnvironments),
           appDir: b.env.appDir,
           did, // root blocklet did
           notification: this.notification,

package/lib/blocklet/registry.js

@@ -57,8 +57,8 @@ class BlockletRegistry {
     return list.some((x) => x.did === id || x.name === id);
   }
 
-  getBlocklet(id) {
-    return this.getBlockletMeta({ did: id });
+  getBlocklet(id, registryUrl) {
+    return this.getBlockletMeta({ did: id, registryUrl });
   }
 
   // eslint-disable-next-line no-unused-vars

package/lib/index.js

@@ -129,7 +129,6 @@ function ABTNode(options) {
     getRoutingSites,
     getSnapshotSites,
     ensureDashboardRouting,
-    ensureIpDnsRouting,
     ensureBlockletRouting,
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
@@ -185,7 +184,7 @@ function ABTNode(options) {
 
     // Blocklet manager
     installBlocklet: blockletManager.install.bind(blockletManager),
-    installBlockletFromUrl: blockletManager.installFromUrl.bind(blockletManager),
+    installBlockletFromVc: blockletManager.installBlockletFromVc.bind(blockletManager),
     startBlocklet: blockletManager.start.bind(blockletManager),
     stopBlocklet: blockletManager.stop.bind(blockletManager),
     reloadBlocklet: blockletManager.reload.bind(blockletManager),
@@ -199,6 +198,7 @@ function ABTNode(options) {
     checkChildBlockletsForUpdates: blockletManager.checkChildrenForUpdates.bind(blockletManager),
     updateChildBlocklets: blockletManager.updateChildren.bind(blockletManager),
     getLatestBlockletVersion: blockletManager.getLatestBlockletVersion.bind(blockletManager),
+    getBlockletMetaFromUrl: blockletManager.getMetaFromUrl.bind(blockletManager),
 
     deleteBlockletProcess: blockletManager.deleteProcess.bind(blockletManager),
 
@@ -214,7 +214,6 @@ function ABTNode(options) {
 
     // Registry
     listBlocklets: blockletRegistry.listBlocklets.bind(blockletRegistry),
-    getBlockletMeta: blockletRegistry.getBlockletMeta.bind(blockletRegistry),
     getRegistryMeta: BlockletRegistry.getRegistryMeta,
 
     // Node State
@@ -305,7 +304,6 @@ function ABTNode(options) {
     takeRoutingSnapshot,
     getSitesFromSnapshot,
     ensureDashboardRouting,
-    ensureIpDnsRouting,
 
     addDomainAlias: routerManager.addDomainAlias.bind(routerManager),
     deleteDomainAlias: routerManager.deleteDomainAlias.bind(routerManager),

package/lib/router/helper.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const tar = require('tar');
 const get = require('lodash/get');
+const joinUrl = require('url-join');
 const { getProvider } = require('@abtnode/router-provider');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const getTmpDirectory = require('@abtnode/util/lib/get-tmp-directory');
@@ -23,7 +24,7 @@ const {
   ROUTING_RULE_TYPES,
   CERTIFICATE_EXPIRES_OFFSET,
   CERTIFICATE_EXPIRES_WARNING_OFFSET,
-  DEFAULT_DASHBOARD_DOMAIN,
+  DEFAULT_DAEMON_PORT,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
@@ -43,7 +44,6 @@ const {
   getWellknownSitePort,
 } = require('../util');
 const { getServicesFromBlockletInterface } = require('../util/service');
-const { getAccessibleIp, getAccessibleIpDnsDomainForNode } = require('../util/get-accessible-ip');
 const getIpDnsDomainForBlocklet = require('../util/get-ip-dns-domain-for-blocklet');
 
 const Router = require('./index');
@@ -208,24 +208,25 @@ const ensureLatestInterfaceInfo = async (sites = []) => {
 
 const ensureWellknownRule = async (sites) => {
   const tempSites = sites || [];
+  const wellknownPort = await getWellknownSitePort();
+
   for (const site of tempSites) {
     // 不向 default site & ip site & wellknown site 添加 wellknown rule
-    const isBasicSites = [
+    const isBasicSite = [
       DOMAIN_FOR_INTERNAL_SITE,
       DOMAIN_FOR_IP_SITE,
       DOMAIN_FOR_DEFAULT_SITE,
       DOMAIN_FOR_IP_SITE_REGEXP,
     ].includes(site.domain);
 
-    if (!isBasicSites) {
+    if (!isBasicSite) {
       const isExists = site.rules.find((x) => x.from.pathPrefix === WELLKNOWN_PATH_PREFIX);
 
       if (!isExists) {
         site.rules.push({
           from: { pathPrefix: WELLKNOWN_PATH_PREFIX },
           to: {
-            // eslint-disable-next-line no-await-in-loop
-            port: await getWellknownSitePort(),
+            port: wellknownPort,
             type: ROUTING_RULE_TYPES.GENERAL_PROXY,
             interfaceName: BLOCKLET_INTERFACE_WELLKNOWN,
           },
@@ -318,27 +319,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   const httpsCertState = states.certificate;
   const notification = states.notification;
 
-  let _nodeDomainRequest = null; // singleton of node-domain-request
-  const _getIpDnsDomainForNode = ({ nodeInfo = {} } = {}) => {
-    const timeout = process.env.NODE_ENV === 'test' ? 500 : 5000;
-    if (_nodeDomainRequest) {
-      return _nodeDomainRequest;
-    }
-
-    const req = getAccessibleIpDnsDomainForNode({ nodeInfo, timeout });
-    _nodeDomainRequest = req;
-
-    req
-      .then(() => {
-        _nodeDomainRequest = null;
-      })
-      .catch(() => {
-        _nodeDomainRequest = null;
-      });
-
-    return req;
-  };
-
   // site level duplication detection
   const hasRuleByPrefix = (site, value) => site.rules.find((x) => x.isProtected && get(x, 'from.pathPrefix') === value);
 
@@ -408,25 +388,47 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
   const addWellknownSite = async (sites, context) => {
     const site = (sites || []).find((x) => x.name === NAME_FOR_WELLKNOWN_SITE);
-    if (site) {
-      return false;
-    }
 
     try {
-      await routerManager.addRoutingSite(
-        {
-          site: {
-            domain: DOMAIN_FOR_INTERNAL_SITE,
-            port: await getWellknownSitePort(),
-            name: NAME_FOR_WELLKNOWN_SITE,
-            rules: [],
-            isProtected: true,
-          },
-          skipCheckDynamicBlacklist: true,
-          skipValidation: true,
+      const pathPrefix = joinUrl(WELLKNOWN_PATH_PREFIX, '/did.json');
+      const didResolverWellknownRule = {
+        from: { pathPrefix },
+        to: {
+          port: DEFAULT_DAEMON_PORT,
+          type: ROUTING_RULE_TYPES.GENERAL_PROXY,
+          interfaceName: BLOCKLET_INTERFACE_WELLKNOWN,
         },
-        context
-      );
+      };
+
+      if (site) {
+        if (site.rules.find((r) => r.from.pathPrefix === normalizePathPrefix(pathPrefix))) {
+          return false;
+        }
+
+        await routerManager.addRoutingRule(
+          {
+            id: site.id,
+            rule: didResolverWellknownRule,
+            skipProtectedRuleChecking: true,
+          },
+          context
+        );
+      } else {
+        await routerManager.addRoutingSite(
+          {
+            site: {
+              domain: DOMAIN_FOR_INTERNAL_SITE,
+              port: await getWellknownSitePort(),
+              name: NAME_FOR_WELLKNOWN_SITE,
+              rules: [didResolverWellknownRule],
+              isProtected: true,
+            },
+            skipCheckDynamicBlacklist: true,
+            skipValidation: true,
+          },
+          context
+        );
+      }
 
       return true;
     } catch (err) {
@@ -555,13 +557,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   const _ensureBlockletSites = async (blocklet, sites, nodeInfo, context = {}) => {
     const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
 
-    const nodeDomain = await _getIpDnsDomainForNode({ nodeInfo });
-
-    if (!nodeDomain) {
-      logger.error('IpDnsDomain of abtnode does not found');
-      return false;
-    }
-
     const getPrefix = (str) => {
       if (!str || str === '*') {
         return '/';
@@ -571,34 +566,57 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const changes = await Promise.all(
       interfaces.map(async (x) => {
-        let changed = false; // if state db changed
+        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 domain = getIpDnsDomainForBlocklet(blocklet, x, nodeDomain);
+        let changed = false; // if state db changed
 
-        if (!(await states.site.domainExists(domain))) {
+        const exist = await states.site.findOne({ domain });
+        if (!exist) {
           await routerManager.addRoutingSite(
             {
               site: {
                 domain,
                 isProtected: true,
-                rules: [
-                  {
-                    from: { pathPrefix: getPrefix(x.prefix) },
-                    to: {
-                      port: findInterfacePortByName(blocklet, x.name),
-                      did: blocklet.meta.did,
-                      type: ROUTING_RULE_TYPES.BLOCKLET,
-                      interfaceName: x.name, // root blocklet interface
-                    },
-                    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,
+              skipProtectedRuleChecking: true,
+            });
+            logger.info('add routing rule for site', { site: domain });
+          }
           changed = true;
         }
 
@@ -614,7 +632,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    *
    * @returns {boolean} if routing changed
    */
-  const _ensureBlockletRulesForWellknownSite = async (blocklet, sites, nodeInfo, context = {}) => {
+  const _ensureBlockletRulesForWellknownSite = async (blocklet, sites, context = {}) => {
     const wellknownSite = sites.find((x) => x.name === NAME_FOR_WELLKNOWN_SITE);
     if (!wellknownSite) {
       return false;
@@ -748,14 +766,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   };
 
   const _removeBlockletSites = async (blocklet, nodeInfo, context = {}) => {
-    const nodeDomain = await _getIpDnsDomainForNode({ nodeInfo });
     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, nodeDomain);
+        const domain = getIpDnsDomainForBlocklet(blocklet, x);
 
         const site = await states.site.findOne({ domain });
         if (
@@ -799,11 +816,20 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const sites = await siteState.getSites();
 
-    const changes = await Promise.all([
-      _ensureBlockletRulesForDashboardSite(blocklet, sites, nodeInfo, context),
-      _ensureBlockletRulesForWellknownSite(blocklet, sites, nodeInfo, context),
+    const tasks = [
+      _ensureBlockletRulesForWellknownSite(blocklet, sites, context),
       _ensureBlockletSites(blocklet, sites, nodeInfo, context),
-    ]);
+    ];
+
+    if (nodeInfo.mode === NODE_MODES.DEBUG || ['e2e', 'test'].includes(process.env.NODE_ENV)) {
+      logger.info('Add blocklet endpoint in dashboard site', {
+        nodeMode: nodeInfo.mode,
+        NODE_ENV: process.env.NODE_ENV,
+      });
+      tasks.push(_ensureBlockletRulesForDashboardSite(blocklet, sites, nodeInfo, context));
+    }
+
+    const changes = await Promise.all(tasks);
 
     return changes.some(Boolean);
   };
@@ -821,72 +847,14 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return false;
     }
 
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
-    const hasInterface = (name) => interfaces.some((x) => x.name === name);
-
-    // If no interfaces found, all routing rules should be removed, this rarely happens, but this logic is needed
-    if (interfaces.length === 0) {
-      return routerManager.deleteRoutingRulesItemByDid({ did: blocklet.meta.did }, context);
-    }
-
-    // First, we need ensure system rules for blocklet on dashboard site
-    let changed = await ensureBlockletRouting(blocklet, context);
-
-    // Then, we need to remove rules whose corresponding interface is not there any more
-    const sites = await siteState.getRulesByDid(blocklet.meta.did);
-    for (const site of sites) {
-      const rulesToRemove = [];
-      const rulesToUpdate = [];
-      for (const rule of site.rules) {
-        if (
-          rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET ||
-          !rule.to.interfaceName ||
-          rule.to.did !== blocklet.meta.did
-        ) {
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-
-        if (hasInterface(rule.to.interfaceName) === false) {
-          rulesToRemove.push(rule.id);
-        }
-
-        if (rule.to.type === ROUTING_RULE_TYPES.BLOCKLET && rule.id === rule.groupId && !rule.isProtected) {
-          rulesToUpdate.push(rule);
-        }
-      }
-
-      for (const rule of rulesToUpdate) {
-        // eslint-disable-next-line no-await-in-loop
-        await routerManager.updateRoutingRule({ id: site.id, rule });
-        changed = true;
-      }
-
-      if (rulesToRemove.length === 0) {
-        // eslint-disable-next-line no-continue
-        continue;
-      }
-
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await states.site.update(
-          { _id: site.id },
-          { $set: { rules: site.rules.filter((x) => rulesToRemove.includes(x.id) === false) } }
-        );
-        changed = true;
-        logger.info('remove routing rule since interface does not exist', { rulesToRemove, did: blocklet.meta.did });
-      } catch (err) {
-        logger.error('failed to remove routing rule since interface does not exist', {
-          rulesToRemove,
-          did: blocklet.meta.did,
-          error: err,
-        });
-      }
-    }
-
-    await _removeBlockletSites(blocklet, nodeInfo, context);
+    await routerManager.deleteRoutingRulesItemByDid(
+      { did: blocklet.meta.did, ruleFilter: (x) => x.isProtected },
+      context
+    );
+    await ensureBlockletRouting(blocklet, context);
 
-    return changed;
+    // Always return true to trigger update of provider
+    return true;
   };
 
   /**
@@ -903,51 +871,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return ruleChanged || siteChanged;
   };
 
-  /**
-   * Refresh ip of in ip-dns-domain if ip changed
-   */
-  const ensureIpDnsRouting = async (context = {}, output) => {
-    const nodeInfo = await nodeState.read();
-    const sites = await siteState.getSites();
-
-    const ip = await getAccessibleIp(nodeInfo);
-    if (!ip) {
-      logger.error('Cannot get get accessible ip for this node');
-      return false;
-    }
-
-    const formattedIp = ip.replace(/\./g, '-');
-    const suffix = DEFAULT_DASHBOARD_DOMAIN.replace(/^\*/, '');
-    const domainSuffixRegex = new RegExp(`(\\d+-\\d+-\\d+-\\d+)${suffix.replace(/\./g, '\\.')}$`); // xxx-xxx-xxx-xxx.ip.abtnet.io
-    const domainSuffix = `${formattedIp}${suffix}`;
-
-    const changes = [];
-
-    sites.forEach((x) => {
-      const match = domainSuffixRegex.exec(x.domain);
-      if (match && match[1] !== formattedIp) {
-        const domain = x.domain.replace(domainSuffixRegex, domainSuffix);
-        changes.push({ id: x.id, domain });
-      }
-    });
-
-    if (changes.length) {
-      for (const change of changes) {
-        // eslint-disable-next-line no-await-in-loop
-        await siteState.update({ _id: change.id }, { $set: { domain: change.domain } });
-        if (typeof output === 'function') {
-          output(`Blocklet endpoint was updated: ${change.domain}`);
-        }
-      }
-
-      const hash = await takeRoutingSnapshot({ message: 'ensure ip dns routing rules', dryRun: false }, context);
-      logger.info('take routing snapshot on ensure dashboard routing rules', { changes, hash });
-      return true;
-    }
-
-    return false;
-  };
-
   async function readRoutingSites() {
     const info = await nodeState.read();
     let snapshotHash = get(info, 'routing.snapshotHash', null);
@@ -1257,7 +1180,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     getCertificates,
     getSitesFromSnapshot,
     checkDomain,
-    ensureIpDnsRouting,
 
     getRoutingCrons: () => [
       {

package/lib/router/index.js

@@ -48,6 +48,23 @@ const mergeAllowedOrigins = (domain, allowedOrigins) => {
   return origins;
 };
 
+const getRoutingTable = ({ sites, nodeInfo }) => {
+  let routingTable = Router.formatSites(sites);
+  routingTable = expandSites(routingTable);
+
+  // put dashboardDomain to last, to let blockletDomain match first
+  // e.g.
+  //  dashboardDomain: 192-168-3-2.ip.abtnet.io
+  //  blockletDomain: static-demo-xxx-192-168-3-2.ip.abtnet.io
+  const dashboardDomain = get(nodeInfo, 'routing.dashboardDomain', '');
+  const index = routingTable.findIndex((x) => x.domain === dashboardDomain);
+  if (index > -1) {
+    routingTable.push(...routingTable.splice(index, 1));
+  }
+
+  return routingTable;
+};
+
 class Router {
   /**
    * Router
@@ -77,12 +94,13 @@ class Router {
 
     logger.info('updateRoutingTable sites:', { sites });
 
-    this.routingTable = Router.formatSites(sites);
+    this.routingTable = getRoutingTable({ sites, nodeInfo });
+
     logger.info('updateRoutingTable routingTable:', { routingTable: this.routingTable });
     logger.info('updateRoutingTable certificates:', { certificates: certificates.map((item) => item.domain) });
 
     await this.provider.update({
-      routingTable: expandSites(this.routingTable),
+      routingTable: this.routingTable,
       certificates,
       globalHeaders: headers,
       services,
@@ -218,5 +236,6 @@ Router.flattenSitesToRules = (sites = [], info = {}) => {
 };
 
 Router._expandSites = expandSites; // eslint-disable-line no-underscore-dangle
+Router._getRoutingTable = getRoutingTable; // eslint-disable-line no-underscore-dangle
 
 module.exports = Router;

package/lib/states/blocklet.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
+const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const detectPort = require('detect-port');
 const Lock = require('@abtnode/util/lib/lock');
@@ -128,8 +129,6 @@ class BlockletState extends BaseState {
             // get ports
             await lock.acquire();
 
-            delete meta.htmlAst;
-
             const ports = await this.getBlockletPorts({ interfaces: sanitized.interfaces || [] });
 
             const children = await this.fillChildrenPorts(this.getChildrenFromMetas(childrenMeta), {
@@ -140,7 +139,7 @@ class BlockletState extends BaseState {
             this.db.insert(
               {
                 mode,
-                meta: sanitized,
+                meta: omit(sanitized, ['htmlAst']),
                 status,
                 source,
                 deployedFrom,
@@ -177,13 +176,15 @@ class BlockletState extends BaseState {
           }
 
           try {
+            fixPerson(meta);
+            fixInterfaces(meta);
+            const sanitized = validateBlockletMeta(meta);
+
             // get ports
             await lock.acquire();
 
-            delete meta.htmlAst;
-
             const ports = await this.getBlockletPorts({
-              interfaces: meta.interfaces || [],
+              interfaces: sanitized.interfaces || [],
               skipOccupiedCheckPorts: getExternalPortsFromMeta(doc.meta),
             });
             Object.keys(ports).forEach((p) => {
@@ -197,7 +198,7 @@ class BlockletState extends BaseState {
             // add to db
             const newDoc = await this.updateById(doc._id, {
               $set: {
-                meta,
+                meta: omit(sanitized, ['htmlAst']),
                 source,
                 deployedFrom,
                 children,

package/lib/util/blocklet.js

@@ -183,17 +183,18 @@ const getBlockletDirs = (blocklet, { rootBlocklet, dataDirs, ensure = false } =
 };
 
 /**
- * set 'configs', userEnvironments', 'systemEnvironments' to blocklet
+ * set 'configs', configObj', 'environmentObj' to blocklet
  * @param {*} blocklet
  * @param {*} configs
  */
 const fillBlockletConfigs = (blocklet, configs) => {
   blocklet.configs = configs || [];
-  blocklet.userEnvironments = blocklet.configs.reduce((acc, x) => {
+  blocklet.configObj = blocklet.configs.reduce((acc, x) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
-  blocklet.systemEnvironments = (blocklet.environments || []).reduce((acc, x) => {
+  blocklet.userEnvironments = blocklet.configObj; // deprecated
+  blocklet.environmentObj = (blocklet.environments || []).reduce((acc, x) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
@@ -222,56 +223,67 @@ const ensureBlockletExpanded = async (meta, appDir) => {
 const getRootSystemEnvironments = (blocklet, nodeInfo) => {
   const { did, name, title, description } = blocklet.meta;
   let wallet;
-  let blockletAppSK;
-  let blockletAppId;
+  let appSk;
+  let appId;
+  let appName = title || name;
+  let appDescription = description || '';
 
   if (process.env.NODE_ENV !== 'test') {
-    const result = getBlockletInfo(blocklet, nodeInfo.sk);
+    const keys = Object.keys(BLOCKLET_CONFIGURABLE_KEY);
+    const result = getBlockletInfo(
+      {
+        meta: blocklet.meta,
+        environments: keys.map((key) => ({ key, value: blocklet.configObj[key] })).filter((x) => x.value),
+      },
+      nodeInfo.sk
+    );
     wallet = result.wallet;
-    blockletAppSK = toHex(wallet.secretKey);
-    blockletAppId = wallet.toAddress();
+    appSk = toHex(wallet.secretKey);
+    appId = wallet.toAddress();
+    appName = appName || result.name;
+    appDescription = appDescription || result.description;
   } else {
-    blockletAppSK = 'AppSK:FIXME:WalletWorksFailedInJest';
-    blockletAppId = 'AppID:FIXME:WalletWorksFailedInJest';
+    appSk = 'AppSK:FIXME:WalletWorksFailedInJest';
+    appId = 'AppID:FIXME:WalletWorksFailedInJest';
   }
 
   return {
     BLOCKLET_DID: did,
-    BLOCKLET_APP_SK: blockletAppSK,
-    BLOCKLET_APP_ID: blockletAppId,
-    BLOCKLET_APP_NAME: title || name,
-    BLOCKLET_APP_DESCRIPTION: description,
+    BLOCKLET_APP_SK: appSk,
+    BLOCKLET_APP_ID: appId,
+    BLOCKLET_APP_NAME: appName,
+    BLOCKLET_APP_DESCRIPTION: appDescription,
   };
 };
 
-const getOverwrittenEnvironments = (blocklet) => {
+const getOverwrittenEnvironments = (blocklet, nodeInfo) => {
   const result = {};
-  if (!blocklet || !blocklet.userEnvironments) {
+  if (!blocklet || !blocklet.configObj) {
     return result;
   }
 
   Object.keys(BLOCKLET_CONFIGURABLE_KEY).forEach((x) => {
-    if (!blocklet.userEnvironments[x]) {
+    if (!blocklet.configObj[x]) {
       return;
     }
 
-    result[x] = blocklet.userEnvironments[x];
+    result[x] = blocklet.configObj[x];
   });
 
   const keys = ['BLOCKLET_APP_SK', 'BLOCKLET_WALLET_TYPE'];
-  const isAppDidRewritten = keys.some((key) => blocklet.userEnvironments[key]);
+  const isAppDidRewritten = keys.some((key) => blocklet.configObj[key]);
   if (!isAppDidRewritten) {
     return result;
   }
 
   // We use user configuration here without any validation since the validation is done during update phase
-  const { wallet } = getBlockletInfo({
-    meta: blocklet.meta,
-    environments: keys.map((key) => ({
-      key,
-      value: blocklet.userEnvironments[key] || blocklet.systemEnvironments[key],
-    })),
-  });
+  const { wallet } = getBlockletInfo(
+    {
+      meta: blocklet.meta,
+      environments: keys.map((key) => ({ key, value: blocklet.configObj[key] })).filter((x) => x.value),
+    },
+    nodeInfo.sk
+  );
   result.BLOCKLET_APP_ID = wallet.toAddress();
 
   return result;
@@ -297,6 +309,21 @@ const getSystemEnvironments = (blocklet) => {
   };
 };
 
+const getRuntimeEnvironments = (blocklet, nodeEnvironments) => {
+  // pm2 will force inject env variables of daemon process to blocklet process
+  // we can only rewrite these private env variables to empty
+  const safeNodeEnvironments = nodePrivateEnvs.reduce((o, x) => {
+    o[x] = '';
+    return o;
+  }, {});
+
+  return {
+    ...blocklet.environmentObj,
+    ...nodeEnvironments,
+    ...safeNodeEnvironments,
+  };
+};
+
 const isUsefulError = (err) => err && err.message !== 'process or namespace not found';
 
 const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {
@@ -376,14 +403,7 @@ const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironment
       const { appMain, appId, appCwd, logsDir } = b.env;
 
       // get env
-      // pm2 will force inject env variables of daemon process to blocklet process
-      // we can only rewrite these private env variables to empty
-      const safeNodeEnvironments = nodePrivateEnvs.reduce((o, x) => {
-        o[x] = '';
-        return o;
-      }, {});
-
-      const env = { ...nodeEnvironments, ...b.systemEnvironments, ...b.userEnvironments, ...safeNodeEnvironments };
+      const env = getRuntimeEnvironments(b, nodeEnvironments);
 
       // run hook
       await preStart(b);
@@ -408,7 +428,7 @@ const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironment
 
       const clusterMode = get(b.meta, 'capabilities.clusterMode', false);
       if (clusterMode && blocklet.mode !== BLOCKLET_MODES.DEVELOPMENT) {
-        const clusterSize = Number(blocklet.userEnvironments.BLOCKLET_CLUSTER_SIZE) || Number.POSITIVE_INFINITY;
+        const clusterSize = Number(blocklet.configObj.BLOCKLET_CLUSTER_SIZE) || Number.POSITIVE_INFINITY;
         options.execMode = 'cluster';
         options.mergeLogs = true;
         options.instances = Math.min(os.cpus().length, clusterSize);
@@ -872,6 +892,7 @@ module.exports = {
   getRootSystemEnvironments,
   getSystemEnvironments,
   getOverwrittenEnvironments,
+  getRuntimeEnvironments,
   validateBlocklet,
   fillBlockletConfigs,
   ensureBlockletExpanded,

package/lib/util/get-accessible-external-node-ip.js

@@ -0,0 +1,41 @@
+const joinUrl = require('url-join');
+const axios = require('@abtnode/util/lib/axios');
+const { DEFAULT_DASHBOARD_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
+const { get: getIp } = require('./ip');
+
+const getNodeDomain = (ip) => (ip ? DEFAULT_DASHBOARD_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
+
+let accessibleIp = null; // cache
+
+const timeout = process.env.NODE_ENV === 'test' ? 500 : 5000;
+
+// check if node dashboard https endpoint return 2xx
+// FIXME: check connected by wellknown endpoint
+const checkConnected = async ({ ip, nodeInfo }) => {
+  const { adminPath = DEFAULT_ADMIN_PATH } = nodeInfo.routing || {};
+  const origin = `https://${getNodeDomain(ip)}`;
+  const endpoint = joinUrl(origin, adminPath);
+  await axios.get(endpoint, { timeout });
+};
+
+/**
+ * Get accessible external ip of abtnode
+ */
+const getAccessibleExternalNodeIp = async (nodeInfo) => {
+  const { external } = await getIp();
+
+  if (accessibleIp === external) {
+    return accessibleIp;
+  }
+
+  try {
+    await checkConnected({ ip: external, nodeInfo });
+    accessibleIp = external;
+  } catch {
+    accessibleIp = null;
+  }
+
+  return accessibleIp;
+};
+
+module.exports = getAccessibleExternalNodeIp;

package/lib/util/get-ip-dns-domain-for-blocklet.js

@@ -1,14 +1,17 @@
 const slugify = require('slugify');
+const { DEFAULT_IP_DNS_DOMAIN_SUFFIX, SLOT_FOR_IP_DNS_SITE } = require('@abtnode/constant');
 
 const formatName = (name) => slugify(name.replace(/^[@./-]/, '').replace(/[@./]/g, '-'));
 
 const hiddenInterfaceNames = ['public', 'publicUrl'];
 
-const getIpDnsDomainForBlocklet = (blocklet, blockletInterface, nodeIpDnsDomain) => {
+const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
   const nameSuffix = blocklet.meta.did.slice(-3).toLowerCase();
   const iName = hiddenInterfaceNames.includes(blockletInterface.name) ? '' : blockletInterface.name.toLowerCase();
 
-  return `${formatName(blocklet.meta.name)}-${nameSuffix}${iName ? '-' : ''}${iName}-${nodeIpDnsDomain}`;
+  return `${formatName(blocklet.meta.name)}-${nameSuffix}${
+    iName ? '-' : ''
+  }${iName}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DNS_DOMAIN_SUFFIX}`;
 };
 
 module.exports = getIpDnsDomainForBlocklet;

package/lib/util/index.js

@@ -27,6 +27,8 @@ const {
   DEFAULT_HTTP_PORT,
   DEFAULT_HTTPS_PORT,
   ROUTING_RULE_TYPES,
+  SLOT_FOR_IP_DNS_SITE,
+  DEFAULT_IP_DNS_DOMAIN_SUFFIX,
 } = require('@abtnode/constant');
 
 const DEFAULT_WELLKNOWN_PORT = 8088;
@@ -71,34 +73,42 @@ const getInterfaceUrl = ({ baseUrl, url, version }) => {
 
 const trimSlash = (str = '') => str.replace(/^\/+/, '').replace(/\/+$/, '');
 
-const getBlockletHost = ({ domain, context }) => {
+const getBlockletHost = ({ domain, context, nodeIp }) => {
+  const { protocol, port } = context || {};
+
   if (domain === DOMAIN_FOR_DEFAULT_SITE) {
     return '';
   }
 
   let tmpDomain = domain;
   if ([DOMAIN_FOR_IP_SITE, DOMAIN_FOR_IP_SITE_REGEXP].includes(domain) || !domain) {
-    tmpDomain = context.hostname;
+    tmpDomain = context.hostname || '';
   }
 
-  if (!context.port) {
-    return tmpDomain;
+  if (tmpDomain.includes(SLOT_FOR_IP_DNS_SITE)) {
+    const ipRegex = /\d+[-.]\d+[-.]\d+[-.]\d+/;
+    const match = ipRegex.exec(context.hostname);
+    if (match) {
+      const ip = match[0].replace(/\./g, '-');
+      tmpDomain = tmpDomain.replace(SLOT_FOR_IP_DNS_SITE, ip);
+    } else if (nodeIp) {
+      tmpDomain = tmpDomain.replace(SLOT_FOR_IP_DNS_SITE, nodeIp.replace(/\./g, '-'));
+    }
   }
 
-  const tmpPort = Number(context.port);
-  if (context.protocol === 'https') {
-    if (tmpPort === 443) {
-      return tmpDomain; // 不展示 https 中的 443 端口
-    }
+  if (!port) {
+    return tmpDomain;
+  }
 
-    return '';
+  if (protocol === 'https' && Number(port) === 443) {
+    return tmpDomain; // 不展示 https 中的 443 端口
   }
 
-  if (tmpPort === 80) {
+  if (Number(port) === 80) {
     return tmpDomain; // 不展示 http 中的 80 端
   }
 
-  return `${tmpDomain}:${context.port}`;
+  return `${tmpDomain}:${port}`;
 };
 
 /**
@@ -145,15 +155,19 @@ const getAuthConfig = (rule, blocklet) => {
   return auth.config;
 };
 
-const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context = {}, blocklet }) => {
-  const protocol = 'http'; // TODO: 这里固定为 http, 因为判断 url 是不是 https 和证书相关，这里实现的话比较复杂
+const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], 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 });
+        const host = getBlockletHost({ domain: site.from.domain, context, nodeIp });
         if (host) {
+          let protocol = 'http'; // TODO: 这里固定为 http, 因为判断 url 是不是 https 和证书相关，这里实现的话比较复杂
+          if (host.includes(DEFAULT_IP_DNS_DOMAIN_SUFFIX)) {
+            protocol = 'https';
+          }
+
           return {
             ruleId: site.id,
             baseUrl: `${protocol}://${host}/${trimSlash(site.from.pathPrefix)}`,
@@ -167,14 +181,14 @@ const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context
       .filter(Boolean);
   }
 
-  if (!baseUrls.length && isIp(context.hostname) && protocol !== 'https') {
-    baseUrls = [{ baseUrl: `${protocol}://${context.hostname}:${port}` }];
+  if (!baseUrls.length && isIp(context.hostname)) {
+    baseUrls = [{ baseUrl: `http://${context.hostname}:${port}` }];
   }
 
   return baseUrls;
 };
 
-const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites }) => {
+const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) => {
   const interfaces = [];
   (blocklet.meta.interfaces || []).forEach((x) => {
     if (x.port && x.port.external) {
@@ -202,6 +216,7 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites }) => {
         }),
         context,
         blocklet,
+        nodeIp,
       });
 
       baseUrls.forEach(({ baseUrl, ruleId, interfaceName, authConfig }) => {

package/lib/util/upgrade.js

@@ -140,7 +140,11 @@ const doUpgrade = async (session) => {
     await goNextState(NODE_UPGRADE_PROGRESS.COMPLETE);
     await sleep(5000);
     await states.node.updateNodeInfo({ nextVersion: '', version: to, upgradeSessionId: '' });
-    await states.node.exitMode(NODE_MODES.MAINTENANCE);
+    try {
+      await states.node.exitMode(NODE_MODES.MAINTENANCE);
+    } catch (error) {
+      logger.error('Failed to exit maintenance mode', { error });
+    }
   }
   await lock.release();
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.4.10",
+  "version": "1.4.14",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,27 +19,28 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/constant": "1.4.10",
-    "@abtnode/cron": "1.4.10",
-    "@abtnode/event-hub": "1.4.10",
-    "@abtnode/logger": "1.4.10",
-    "@abtnode/queue": "1.4.10",
-    "@abtnode/rbac": "1.4.10",
-    "@abtnode/router-provider": "1.4.10",
-    "@abtnode/static-server": "1.4.10",
-    "@abtnode/timemachine": "1.4.10",
-    "@abtnode/util": "1.4.10",
-    "@arcblock/did": "^1.13.2",
+    "@abtnode/constant": "1.4.14",
+    "@abtnode/cron": "1.4.14",
+    "@abtnode/event-hub": "1.4.14",
+    "@abtnode/logger": "1.4.14",
+    "@abtnode/queue": "1.4.14",
+    "@abtnode/rbac": "1.4.14",
+    "@abtnode/router-provider": "1.4.14",
+    "@abtnode/static-server": "1.4.14",
+    "@abtnode/timemachine": "1.4.14",
+    "@abtnode/util": "1.4.14",
+    "@arcblock/did": "^1.13.15",
     "@arcblock/pm2-events": "^0.0.5",
-    "@blocklet/meta": "1.4.10",
+    "@arcblock/vc": "^1.13.15",
+    "@blocklet/meta": "1.4.14",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.1.0",
     "@nedb/multi": "^1.1.0",
-    "@ocap/mcrypto": "^1.13.2",
-    "@ocap/util": "^1.13.2",
-    "@ocap/wallet": "^1.13.2",
+    "@ocap/mcrypto": "^1.13.15",
+    "@ocap/util": "^1.13.15",
+    "@ocap/wallet": "^1.13.15",
     "@slack/webhook": "^5.0.3",
-    "axios": "^0.21.1",
+    "axios": "^0.21.4",
     "axon": "^2.0.3",
     "chalk": "^4.0.0",
     "deep-diff": "^1.0.2",
@@ -71,5 +72,5 @@
     "express": "^4.17.1",
     "jest": "^26.4.2"
   },
-  "gitHead": "1a03df394c4c430975a369ebb4dadcf2e2e085bb"
+  "gitHead": "9176b462ff92c787e18a8b218f06a451aad4cf1d"
 }

package/lib/util/get-accessible-ip.js

@@ -1,42 +0,0 @@
-const joinUrl = require('url-join');
-const axios = require('@abtnode/util/lib/axios');
-const getIp = require('@abtnode/util/lib/get-ip');
-const { DEFAULT_DASHBOARD_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
-
-const getNodeDomain = (ip) => (ip ? DEFAULT_DASHBOARD_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
-
-const getAccessibleIp = async ({ nodeInfo = {}, timeout = 5000 } = {}) => {
-  const { adminPath = DEFAULT_ADMIN_PATH } = nodeInfo.routing || {};
-
-  // check if node dashboard https endpoint return 2xx
-  // FIXME: check connected by wellknown endpoint
-  const checkConnected = async ({ ip }) => {
-    const origin = `https://${getNodeDomain(ip)}`;
-    const endpoint = joinUrl(origin, adminPath);
-    await axios.get(endpoint, { timeout });
-  };
-
-  const { internal, external } = await getIp({ timeout });
-
-  if (!external) {
-    return internal;
-  }
-
-  try {
-    await checkConnected({ ip: external });
-    return external;
-  } catch {
-    return internal;
-  }
-};
-
-const getAccessibleIpDnsDomainForNode = async ({ nodeInfo = {}, timeout = 5000 } = {}) => {
-  const accessibleIp = await getAccessibleIp({ nodeInfo, timeout });
-
-  return getNodeDomain(accessibleIp);
-};
-
-module.exports = {
-  getAccessibleIp,
-  getAccessibleIpDnsDomainForNode,
-};