@abtnode/core 1.8.32 → 1.8.34

package/lib/blocklet/manager/disk.js

@@ -3,6 +3,7 @@
 const fs = require('fs-extra');
 const { fileURLToPath } = require('url');
 const path = require('path');
+const urlHttp = require('url-http');
 const get = require('lodash/get');
 const pick = require('lodash/pick');
 const cloneDeep = require('lodash/cloneDeep');
@@ -70,6 +71,7 @@ const {
   BLOCKLET_META_FILE,
   BLOCKLET_CONFIGURABLE_KEY,
 } = require('@blocklet/constant');
+const { isEmpty } = require('lodash');
 const util = require('../../util');
 const {
   refresh: refreshAccessibleExternalNodeIp,
@@ -122,7 +124,6 @@ const handleInstanceInStore = require('../../util/public-to-store');
 const {
   isInProgress,
   isBeforeInstalled,
-  getBlockletInterfaces,
   formatEnvironments,
   shouldUpdateBlockletStatus,
   getBlockletMeta,
@@ -449,8 +450,14 @@ class BlockletManager extends BaseBlockletManager {
 
       if (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT) {
         const { logsDir } = blocklet.env;
-        fs.removeSync(logsDir);
-        fs.mkdirSync(logsDir, { recursive: true });
+
+        try {
+          fs.removeSync(logsDir);
+          fs.mkdirSync(logsDir, { recursive: true });
+        } catch {
+          // Windows && Node.js 18.x 下会发生删除错误(ENOTEMPTY)
+          // 但是这个错误并不影响后续逻辑，所以这里对这个错误做了 catch
+        }
       }
 
       const getHookFn =
@@ -972,6 +979,16 @@ class BlockletManager extends BaseBlockletManager {
         }
       }
 
+      if (x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_STORAGE_ENDPOINT) {
+        if (isEmpty(x.value)) {
+          throw new Error(`${x.key} can not be empty`);
+        }
+
+        if (!urlHttp(x.value)) {
+          throw new Error(`${x.key}(${x.value}) is not a valid http address`);
+        }
+      }
+
       blocklet.configObj[x.key] = x.value;
     }
 
@@ -1563,12 +1580,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async getBlockletInterfaces({ blocklet, nodeInfo, context }) {
-    const routingRules = await this.getRoutingRulesByDid(blocklet.meta.did);
-    const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
-    return getBlockletInterfaces({ blocklet, context, routingRules, nodeIp });
-  }
-
   async attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
     if (!did) {
       throw new Error('did should not be empty');
@@ -1597,8 +1608,6 @@ class BlockletManager extends BaseBlockletManager {
         }));
       }
 
-      blocklet.interfaces = await this.getBlockletInterfaces({ blocklet, nodeInfo, context });
-
       if (!fromCache) {
         blocklet.engine = getEngine(getBlockletEngineNameByPlatform(blocklet.meta)).describe();
         blocklet.diskInfo = await getDiskInfo(blocklet, { useFakeDiskInfo: !diskInfo });

package/lib/event.js

@@ -27,6 +27,7 @@ module.exports = ({
   teamAPI,
   teamManager,
   certManager,
+  routerManager,
   node,
 }) => {
   const notificationState = states.notification;
@@ -248,7 +249,22 @@ module.exports = ({
     }
   };
 
-  Object.values(BlockletEvents).forEach((eventName) => {
+  [
+    BlockletEvents.added,
+    BlockletEvents.downloadFailed,
+    BlockletEvents.installed,
+    BlockletEvents.installFailed,
+    BlockletEvents.upgraded,
+    BlockletEvents.upgradeFailed,
+    BlockletEvents.downgraded,
+    BlockletEvents.downgradeFailed,
+    BlockletEvents.updated,
+    BlockletEvents.statusChange,
+    BlockletEvents.removed,
+    BlockletEvents.started,
+    BlockletEvents.startFailed,
+    BlockletEvents.stopped,
+  ].forEach((eventName) => {
     blockletManager.on(eventName, (data) => handleBlockletEvent(eventName, data));
   });
 
@@ -276,10 +292,12 @@ module.exports = ({
     });
   });
 
-  domainStatus.on(EVENTS.DOMAIN_STATUS, (data) => {
-    if (data) {
-      onEvent(EVENTS.DOMAIN_STATUS, data);
-    }
+  [EVENTS.DOMAIN_STATUS, BlockletEvents.domainStatus].forEach((eventName) => {
+    domainStatus.on(eventName, (data) => {
+      if (data) {
+        onEvent(eventName, data);
+      }
+    });
   });
 
   teamAPI.on(EVENTS.USER_ADDED, (data) => onEvent(EVENTS.USER_ADDED, data));
@@ -290,6 +308,8 @@ module.exports = ({
   certManager.on('cert.issued', (data) => onEvent(EVENTS.CERT_ISSUED, data));
   certManager.on('cert.error', (data) => onEvent(EVENTS.CERT_ERROR, data));
 
+  routerManager.on(BlockletEvents.updated, (data) => onEvent(BlockletEvents.updated, data));
+
   events.setEventHandler = (handler) => {
     if (typeof handler === 'function') {
       eventHandler = handler;

package/lib/index.js

@@ -136,8 +136,6 @@ function ABTNode(options) {
 
   const {
     handleRouting,
-    getRoutingRulesByDid,
-    getSiteByDid,
     resetSiteByDid,
     updateNodeRouting,
     takeRoutingSnapshot,
@@ -152,19 +150,25 @@ function ABTNode(options) {
     getRoutingCrons,
     ensureWildcardCerts,
     getRouterProvider,
+    addRoutingSite,
+    deleteRoutingSite,
+    updateRoutingSite,
+    addRoutingRule,
+    updateRoutingRule,
+    deleteRoutingRule,
+    addDomainAlias,
+    deleteDomainAlias,
   } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager });
 
   const nodeAPI = new NodeAPI(states.node);
   const teamAPI = new TeamAPI({ states, teamManager, dataDirs });
 
-  blockletManager.getRoutingRulesByDid = getRoutingRulesByDid;
-  blockletManager.getSiteByDid = getSiteByDid;
   blockletManager.resetSiteByDid = resetSiteByDid;
 
   // Generate an on node ready callback
   const onStatesReady = createStateReadyQueue({ states, options, dataDirs });
   onStatesReady(createStateReadyHandler(routingSnapshot));
-  const domainStatus = new DomainStatus(routerManager);
+  const domainStatus = new DomainStatus({ routerManager, states });
 
   const isInitialized = async () => {
     const state = await states.node.read();
@@ -318,12 +322,12 @@ function ABTNode(options) {
 
     // Routing
     routerManager,
-    addRoutingSite: routerManager.addRoutingSite.bind(routerManager),
-    deleteRoutingSite: routerManager.deleteRoutingSite.bind(routerManager),
-    updateRoutingSite: routerManager.updateRoutingSite.bind(routerManager),
-    addRoutingRule: routerManager.addRoutingRule.bind(routerManager),
-    updateRoutingRule: routerManager.updateRoutingRule.bind(routerManager),
-    deleteRoutingRule: routerManager.deleteRoutingRule.bind(routerManager),
+    addRoutingSite,
+    deleteRoutingSite,
+    updateRoutingSite,
+    addRoutingRule,
+    updateRoutingRule,
+    deleteRoutingRule,
     getRoutingRuleById: states.site.getRuleById.bind(states.site),
     getRoutingSites: (params, context) => getRoutingSites(params, context, { withDefaultCors: false }),
     getRoutingSnapshots: routingSnapshot.listSnapshots.bind(routingSnapshot),
@@ -333,8 +337,8 @@ function ABTNode(options) {
     ensureDashboardRouting,
     ensureWildcardCerts,
 
-    addDomainAlias: routerManager.addDomainAlias.bind(routerManager),
-    deleteDomainAlias: routerManager.deleteDomainAlias.bind(routerManager),
+    addDomainAlias,
+    deleteDomainAlias,
 
     getRoutingProviders: () => listProviders(dataDirs.router),
     checkDomains: domainStatus.checkDomainsStatus.bind(domainStatus),
@@ -398,6 +402,7 @@ function ABTNode(options) {
     teamAPI,
     teamManager,
     certManager,
+    routerManager,
     node: instance,
   });
 

package/lib/migrations/1.8.33-blocklet-mem-limit.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+const { BLOCKLET_MAX_MEM_LIMIT_IN_MB } = require('@abtnode/constant');
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update blockletMaxMemoryLimit...');
+
+  const info = await states.node.read();
+  if (
+    info?.runtimeConfig?.blockletMaxMemoryLimit &&
+    info.runtimeConfig.blockletMaxMemoryLimit < BLOCKLET_MAX_MEM_LIMIT_IN_MB
+  ) {
+    info.runtimeConfig.blockletMaxMemoryLimit = BLOCKLET_MAX_MEM_LIMIT_IN_MB;
+    await states.node.updateNodeInfo(info);
+    printInfo(`Update blockletMaxMemoryLimit to ${BLOCKLET_MAX_MEM_LIMIT_IN_MB}MB`);
+  } else {
+    printInfo(`No need to update blockletMaxMemoryLimit (${info?.runtimeConfig?.blockletMaxMemoryLimit}MB)`);
+  }
+};

package/lib/router/helper.js

@@ -37,19 +37,12 @@ const {
   BLOCKLET_INTERFACE_TYPE_WEB,
   BLOCKLET_INTERFACE_WELLKNOWN,
   BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
+  BlockletEvents,
 } = require('@blocklet/constant');
 
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../package.json').name}:router:helper`);
-const {
-  getProviderFromNodeInfo,
-  trimSlash,
-  getInterfaceUrl,
-  getBlockletHost,
-  getHttpsCertInfo,
-  findInterfacePortByName,
-  getWellknownSitePort,
-} = require('../util');
+const { getProviderFromNodeInfo, getHttpsCertInfo, findInterfacePortByName, getWellknownSitePort } = require('../util');
 const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
@@ -61,6 +54,10 @@ const { getBlockletDomainGroupName, getDidFromDomainGroupName } = require('../ut
  * replace 888-888-888-888 with accessible ip for domain
  */
 const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) => {
+  if (!sites) {
+    return [];
+  }
+
   let ip;
   const ipRegex = /\d+[-.]\d+[-.]\d+[-.]\d+/;
   const match = ipRegex.exec(context.hostname);
@@ -97,89 +94,6 @@ const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) =>
   });
 };
 
-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);
-    if (prefix) {
-      return `http://${host}/${prefix}/`;
-    }
-
-    return `http://${host}/`;
-  };
-
-  const blocklets = await states.blocklet.getBlocklets();
-  const getInterfaces = (site) =>
-    (site.rules || []).map((tmpRule) => {
-      const rule = { ...tmpRule };
-
-      const ruleId = tmpRule.id;
-      const baseUrl = getUrl(rule, site.domain);
-
-      const interfaces = [];
-      if (rule.to.type === ROUTING_RULE_TYPES.BLOCKLET) {
-        const blocklet = blocklets.find((b) => b.meta.did === rule.to.did);
-
-        if (!blocklet) {
-          logger.warn(`can not attach interface urls for non-existing blocklet ${rule.to.did}`);
-          rule.interfaces = interfaces;
-          return rule;
-        }
-
-        if (!getBlockletHost({ domain: site.domain, context })) {
-          logger.warn('blocklet host does not exist');
-          rule.interfaces = interfaces;
-          return rule;
-        }
-
-        (blocklet.meta.interfaces || []).forEach((x) => {
-          if (x.port && !x.port.external) {
-            interfaces.push({
-              ruleId,
-              type: x.type,
-              name: x.name,
-              url: getInterfaceUrl({ baseUrl, url: '/' }),
-            });
-          }
-        });
-      } else if (rule.to.type === ROUTING_RULE_TYPES.REDIRECT || rule.to.type === ROUTING_RULE_TYPES.NONE) {
-        interfaces.push({
-          ruleId,
-          type: 'web',
-          name: ROUTING_RULE_TYPES.REDIRECT,
-          url: baseUrl,
-        });
-      } else {
-        interfaces.push({
-          ruleId,
-          type: 'web',
-          name: 'default',
-          url: getUrl(rule),
-        });
-      }
-
-      rule.interfaces = interfaces;
-      return rule;
-    });
-
-  if (!Array.isArray(sites)) {
-    sites.rules = getInterfaces(sites);
-    return sites;
-  }
-
-  return sites.map((site) => {
-    site.rules = getInterfaces(site);
-
-    return site;
-  });
-};
-
 const addCorsToSite = (site, rawUrl) => {
   if (!site || !rawUrl) {
     return;
@@ -1019,23 +933,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return result;
   }
 
-  async function getRoutingRulesByDid(did) {
-    const info = await nodeState.read();
-    const { sites } = await readRoutingSites();
-    const domain = getBlockletDomainGroupName(did);
-    const rules = Router.flattenSitesToRules(
-      (sites || []).filter((x) => x.domain === domain),
-      info
-    );
-    return rules.filter((rule) => rule.to.did === did);
-  }
-
-  async function getSiteByDid(did) {
-    const { sites } = await readRoutingSites();
-    const domain = getBlockletDomainGroupName(did);
-    return (sites || []).find((x) => x.domain === domain);
-  }
-
   async function resetSiteByDid(did, { refreshRouterProvider = true } = {}) {
     const blocklet = await states.blocklet.getBlocklet(did);
     await removeBlockletRouting(blocklet);
@@ -1246,7 +1143,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return sites;
     }
 
-    return attachInterfaceUrls({
+    return attachRuntimeDomainAliases({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
       node: nodeState,
@@ -1255,7 +1152,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
   const getSnapshotSites = async ({ hash }, context = {}, { withDefaultCors = true } = {}) => {
     const sites = await routingSnapshot.readSnapshotSites(hash);
-    return attachInterfaceUrls({
+    return attachRuntimeDomainAliases({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
       node: nodeState,
@@ -1284,14 +1181,41 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     });
   };
 
+  /**
+   * proxy to routerManager and do takeRoutingSnapshot
+   */
+  const _proxyToRouterManager =
+    (fnName) =>
+    async (...args) => {
+      const res = await routerManager[fnName](...args);
+
+      takeRoutingSnapshot({ message: fnName, dryRun: false }).catch((error) => {
+        logger.error('failed to takeRoutingSnapshot', { error });
+      });
+
+      const { teamDid: did } = args[0] || {};
+      if (did) {
+        routerManager.emit(BlockletEvents.updated, { meta: { did } });
+      }
+
+      return res;
+    };
+
+  const addRoutingSite = _proxyToRouterManager('addRoutingSite');
+  const updateRoutingSite = _proxyToRouterManager('updateRoutingSite');
+  const deleteRoutingSite = _proxyToRouterManager('deleteRoutingSite');
+  const addRoutingRule = _proxyToRouterManager('addRoutingRule');
+  const updateRoutingRule = _proxyToRouterManager('updateRoutingRule');
+  const deleteRoutingRule = _proxyToRouterManager('deleteRoutingRule');
+  const addDomainAlias = _proxyToRouterManager('addDomainAlias');
+  const deleteDomainAlias = _proxyToRouterManager('deleteDomainAlias');
+
   return {
     ensureDashboardRouting,
     ensureBlockletRouting,
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
     handleRouting,
-    getRoutingRulesByDid,
-    getSiteByDid,
     resetSiteByDid,
     updateNodeRouting,
     takeRoutingSnapshot,
@@ -1318,10 +1242,19 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         options: { runOnInit: false },
       },
     ],
+
+    addRoutingSite,
+    deleteRoutingSite,
+    updateRoutingSite,
+    addRoutingRule,
+    updateRoutingRule,
+    deleteRoutingRule,
+    addDomainAlias,
+    deleteDomainAlias,
   };
 };
 
-module.exports.attachInterfaceUrls = attachInterfaceUrls;
+module.exports.attachRuntimeDomainAliases = attachRuntimeDomainAliases;
 module.exports.ensureLatestNodeInfo = ensureLatestNodeInfo;
 module.exports.ensureLatestInterfaceInfo = ensureLatestInterfaceInfo;
 module.exports.ensureLatestInfo = ensureLatestInfo;

package/lib/router/manager.js

@@ -39,7 +39,7 @@ const {
 } = require('../validators/router');
 const { getProviderFromNodeInfo, findInterfaceByName, isCLI, findInterfacePortByName } = require('../util');
 const { findWebInterface } = require('../util/blocklet');
-const { attachInterfaceUrls, ensureLatestInfo } = require('./helper');
+const { attachRuntimeDomainAliases, ensureLatestInfo } = require('./helper');
 const Router = require('./index');
 const states = require('../states');
 
@@ -124,7 +124,7 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('addRoutingSite', { site: newSite });
 
     const result = await states.site.add(newSite);
-    await attachInterfaceUrls({ sites: result, context, node: states.node });
+    await attachRuntimeDomainAliases({ sites: result, context, node: states.node });
 
     this.emit('router.site.created', result);
     return result;
@@ -184,7 +184,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, node: states.node });
+    await attachRuntimeDomainAliases({ sites: dbSite, context, node: states.node });
     return dbSite;
   }
 
@@ -228,7 +228,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, node: states.node });
+    await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     return newSite;
   }
@@ -251,7 +251,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, node: states.node });
+    await attachRuntimeDomainAliases({ sites: dbSite, context, node: states.node });
 
     return dbSite;
   }
@@ -286,7 +286,7 @@ class RouterManager extends EventEmitter {
     }
 
     const newSite = await states.site.findOne({ _id: id });
-    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
+    await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.created', newSite);
     return newSite;
@@ -330,7 +330,7 @@ class RouterManager extends EventEmitter {
     logger.info('update result', { updateResult });
     const newSite = await states.site.findOne({ _id: id });
 
-    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
+    await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.updated', newSite);
 
@@ -359,7 +359,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, node: states.node });
+    await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.removed', newSite);
     return newSite;

package/lib/states/site.js

@@ -2,6 +2,7 @@ const logger = require('@abtnode/logger')('@abtnode/core:states:site');
 const { toSlotDomain } = require('@abtnode/router-provider/lib/util');
 
 const BaseState = require('./base');
+const { getBlockletDomainGroupName } = require('../util/router');
 
 class SiteState extends BaseState {
   constructor(baseDir, config = {}) {
@@ -72,6 +73,16 @@ class SiteState extends BaseState {
       $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
     });
   }
+
+  async findOneByBlocklet(did) {
+    const result = await this.findOne({ domain: getBlockletDomainGroupName(did) });
+    return BaseState.renameIdFiledName(result);
+  }
+
+  async getBlockletDomains(did) {
+    const site = await this.findOneByBlocklet(did);
+    return site.domainAliases.map((x) => x.value).filter(Boolean);
+  }
 }
 
 module.exports = SiteState;

package/lib/util/blocklet.js

@@ -71,7 +71,6 @@ const { validate: validateEngine, get: getEngine } = require('../blocklet/manage
 
 const isRequirementsSatisfied = require('./requirement');
 const { getDidDomainForBlocklet } = require('./get-domain-for-blocklet');
-const { getBlockletDomainGroupName } = require('./router');
 const { isBeforeInstalled, expandBundle, findInterfacePortByName, validateBlockletMeta } = require('./index');
 
 const getComponentConfig = (meta) => meta.components || meta.children;
@@ -1332,9 +1331,7 @@ const getBlocklet = async ({
   blocklet.settings = settings || {};
 
   // app site
-  const sites = await states.site.getSites();
-  const domain = getBlockletDomainGroupName(blocklet.meta.did);
-  blocklet.site = (sites || []).find((x) => x.domain === domain);
+  blocklet.site = await states.site.findOneByBlocklet(blocklet.meta.did);
 
   await forEachBlocklet(blocklet, async (component, { id, level, ancestors }) => {
     // component env

package/lib/util/domain-status.js

@@ -2,34 +2,48 @@ const https = require('https');
 const { EventEmitter } = require('events');
 const logger = require('@abtnode/logger')('@abtnode/domain-status');
 const { EVENTS, WELLKNOWN_PING_PREFIX } = require('@abtnode/constant');
+const { BlockletEvents } = require('@blocklet/constant');
 const { checkDomainDNS } = require('./index');
 
 const dnsStatusStore = Object.create(null);
 
-const checkDomainDnsWrapper = async (domain) => {
-  // 正在执行，并且离上次的执行时间小于 2 分钟则不请求
-  if (dnsStatusStore[domain] && Date.now() - dnsStatusStore[domain] < 2 * 60 * 1000) {
-    return {};
-  }
-
+const doCheckDomainDnsWrapper = async (domain) => {
   try {
-    dnsStatusStore[domain] = Date.now();
     const status = await checkDomainDNS(domain);
     return status;
   } catch (error) {
     logger.error('check domain dns error', { domain, error });
     throw error;
   } finally {
-    delete dnsStatusStore[domain];
     logger.debug('removed dns flag', { domain });
   }
 };
 
+const checkDomainDnsWrapper = (domain) => {
+  // 正在执行或已成功，并且离上次的执行时间小于 2 分钟则不请求
+  if (dnsStatusStore[domain] && Date.now() - dnsStatusStore[domain].startAt < 2 * 60 * 1000) {
+    return dnsStatusStore[domain].promise;
+  }
+
+  const promise = doCheckDomainDnsWrapper(domain);
+  dnsStatusStore[domain] = {
+    promise,
+    startAt: Date.now(),
+  };
+
+  promise.catch(() => {
+    delete dnsStatusStore[domain];
+  });
+
+  return promise;
+};
+
 class DomainStatus extends EventEmitter {
-  constructor(routerManager) {
+  constructor({ routerManager, states }) {
     super();
 
     this.routerManager = routerManager;
+    this.states = states;
   }
 
   async getHttpsCert(domain) {
@@ -74,15 +88,26 @@ class DomainStatus extends EventEmitter {
     });
   }
 
-  checkDomainsStatus({ domains } = {}) {
+  async checkDomainsStatus({ domains, did } = {}) {
+    if (did) {
+      // eslint-disable-next-line no-param-reassign
+      domains = await this.states.site.getBlockletDomains(did);
+    }
+
     (domains || []).forEach((domain) => {
       Promise.all([this.getHttpsCert(domain), checkDomainDnsWrapper(domain)])
-        .then((data) => {
-          const [matchedCert, dns] = data;
-          this.emit(EVENTS.DOMAIN_STATUS, { domain, matchedCert, isHttps: !!matchedCert, dns });
+        .then(([matchedCert, dns]) => {
+          const eventData = { domain, matchedCert, isHttps: !!matchedCert, dns };
+
+          if (did) {
+            eventData.meta = { did };
+            this.emit(BlockletEvents.domainStatus, eventData);
+          } else {
+            this.emit(EVENTS.DOMAIN_STATUS, eventData);
+          }
         })
         .catch((error) => {
-          logger.error('check domain status error', { domain, error });
+          logger.error('check domain status error', { domain, error, did });
         });
     });
 

package/lib/util/index.js

@@ -6,7 +6,6 @@ const unzipper = require('unzipper');
 const crypto = require('crypto');
 const shell = require('shelljs');
 const get = require('lodash/get');
-const uniqBy = require('lodash/uniqBy');
 const pickBy = require('lodash/pickBy');
 const { isFromPublicKey } = require('@arcblock/did');
 const joinUrl = require('url-join');
@@ -17,7 +16,7 @@ const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const axios = require('@abtnode/util/lib/axios');
 const parseBlockletMeta = require('@blocklet/meta/lib/parse');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
-const { BlockletStatus, BLOCKLET_INTERFACE_WELLKNOWN } = require('@blocklet/constant');
+const { BlockletStatus } = require('@blocklet/constant');
 const { replaceSlotToIp } = require('@blocklet/meta/lib/util');
 const {
   StatusCode,
@@ -26,10 +25,7 @@ const {
   DOMAIN_FOR_IP_SITE_REGEXP,
   DEFAULT_HTTP_PORT,
   DEFAULT_HTTPS_PORT,
-  ROUTING_RULE_TYPES,
   SLOT_FOR_IP_DNS_SITE,
-  DEFAULT_IP_DOMAIN_SUFFIX,
-  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
 
 const DEFAULT_WELLKNOWN_PORT = 8088;
@@ -50,22 +46,6 @@ const fromStatus = (v) => {
   return match ? match[0] : 'unknown';
 };
 
-const getInterfaceUrl = ({ baseUrl, url }) => {
-  if (!url) {
-    return '';
-  }
-
-  if (url.startsWith('https://') || url.startsWith('http://')) {
-    return url;
-  }
-
-  const parsed = new URL(joinUrl(baseUrl, url));
-
-  return parsed.href;
-};
-
-const trimSlash = (str = '') => str.replace(/^\/+/, '').replace(/\/+$/, '');
-
 const replaceDomainSlot = ({ domain, context = {}, nodeIp }) => {
   let processed = domain;
   if (processed.includes(SLOT_FOR_IP_DNS_SITE)) {
@@ -110,71 +90,6 @@ const getBlockletHost = ({ domain, context, nodeIp }) => {
   return `${tmpDomain}:${port}`;
 };
 
-const getBlockletBaseUrls = ({ rules = [], context = {}, nodeIp }) => {
-  if (!Array.isArray(rules) || !rules.length) {
-    return [];
-  }
-
-  return rules
-    .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_DOMAIN_SUFFIX)) {
-          protocol = 'https';
-        }
-
-        return {
-          ruleId: rule.id,
-          baseUrl: `${protocol}://${host}/${trimSlash(rule.from.pathPrefix)}`,
-          interfaceName: get(rule, 'to.interfaceName', ''),
-        };
-      }
-
-      return null;
-    })
-    .filter(Boolean);
-};
-
-const getBlockletInterfaces = ({ blocklet, context, routingRules, nodeIp }) => {
-  const interfaces = [];
-  (blocklet.meta.interfaces || [])
-    .filter((x) => !get(x, 'port.external'))
-    .forEach((x) => {
-      // Otherwise, the url is composed with routing rules
-      const baseUrls = getBlockletBaseUrls({
-        rules: (routingRules || []).filter((r) => {
-          return (
-            // don't show group domain
-            !(r.from.domain || '').endsWith(BLOCKLET_SITE_GROUP_SUFFIX) &&
-            // 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)
-          );
-        }),
-        context,
-        nodeIp,
-      });
-
-      baseUrls.forEach(({ baseUrl, ruleId, interfaceName }) => {
-        if (interfaceName && interfaceName !== x.name) {
-          return;
-        }
-        interfaces.push({
-          ruleId,
-          type: x.type,
-          name: x.name,
-          url: getInterfaceUrl({ baseUrl, url: '/' }),
-        });
-      });
-    });
-
-  return uniqBy(interfaces, 'url');
-};
-
 const isRoutingEnabled = (routing) => !!routing && !!routing.provider;
 
 const isInProgress = (status) =>
@@ -487,15 +402,11 @@ const lib = {
   formatEnvironments,
   isInProgress,
   isBeforeInstalled,
-  getInterfaceUrl,
-  getBlockletBaseUrls,
   replaceDomainSlot,
   getBlockletHost,
-  getBlockletInterfaces,
   isRoutingEnabled,
   checkDomainDNS,
   asyncExec,
-  trimSlash,
   isCLI,
   getHttpsCertInfo,
   ensureDataDirs,

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.32",
+  "version": "1.8.34",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,32 +19,32 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.8.32",
-    "@abtnode/certificate-manager": "1.8.32",
-    "@abtnode/constant": "1.8.32",
-    "@abtnode/cron": "1.8.32",
-    "@abtnode/db": "1.8.32",
-    "@abtnode/logger": "1.8.32",
-    "@abtnode/queue": "1.8.32",
-    "@abtnode/rbac": "1.8.32",
-    "@abtnode/router-provider": "1.8.32",
-    "@abtnode/static-server": "1.8.32",
-    "@abtnode/timemachine": "1.8.32",
-    "@abtnode/util": "1.8.32",
-    "@arcblock/did": "1.18.1",
+    "@abtnode/auth": "1.8.34",
+    "@abtnode/certificate-manager": "1.8.34",
+    "@abtnode/constant": "1.8.34",
+    "@abtnode/cron": "1.8.34",
+    "@abtnode/db": "1.8.34",
+    "@abtnode/logger": "1.8.34",
+    "@abtnode/queue": "1.8.34",
+    "@abtnode/rbac": "1.8.34",
+    "@abtnode/router-provider": "1.8.34",
+    "@abtnode/static-server": "1.8.34",
+    "@abtnode/timemachine": "1.8.34",
+    "@abtnode/util": "1.8.34",
+    "@arcblock/did": "1.18.13",
     "@arcblock/did-motif": "^1.1.10",
-    "@arcblock/did-util": "1.18.1",
-    "@arcblock/event-hub": "1.18.1",
-    "@arcblock/jwt": "^1.18.1",
+    "@arcblock/did-util": "1.18.13",
+    "@arcblock/event-hub": "1.18.13",
+    "@arcblock/jwt": "^1.18.13",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "1.18.1",
-    "@blocklet/constant": "1.8.32",
-    "@blocklet/meta": "1.8.32",
-    "@blocklet/sdk": "1.8.32",
+    "@arcblock/vc": "1.18.13",
+    "@blocklet/constant": "1.8.34",
+    "@blocklet/meta": "1.8.34",
+    "@blocklet/sdk": "1.8.34",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.1",
-    "@ocap/util": "1.18.1",
-    "@ocap/wallet": "1.18.1",
+    "@ocap/mcrypto": "1.18.13",
+    "@ocap/util": "1.18.13",
+    "@ocap/wallet": "1.18.13",
     "@slack/webhook": "^5.0.4",
     "axios": "^0.27.2",
     "axon": "^2.0.3",
@@ -72,6 +72,7 @@
     "tar": "^6.1.11",
     "ua-parser-js": "^1.0.2",
     "unzipper": "^0.10.11",
+    "url-http": "^1.0.7",
     "url-join": "^4.0.1",
     "uuid": "7.0.3"
   },
@@ -81,5 +82,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "8502244aeda5926b3433c1dd9142e63233e3c23c"
+  "gitHead": "c5fbb8e57493db62f212217cfde1980c82f00297"
 }