@abtnode/core 1.6.25 → 1.6.28

package/lib/api/team.js

@@ -1,7 +1,7 @@
 const { EventEmitter } = require('events');
 const pick = require('lodash/pick');
 const logger = require('@abtnode/logger')('@abtnode/core:api:team');
-const { ROLES, genPermissionName } = require('@abtnode/constant');
+const { ROLES, genPermissionName, EVENTS } = require('@abtnode/constant');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { BlockletEvents } = require('@blocklet/meta/lib/constants');
 const { validateTrustedPassportIssuers } = require('../validators/trusted-passport');
@@ -62,7 +62,7 @@ class TeamAPI extends EventEmitter {
       });
     }
 
-    this.emit('user.added', { teamDid, user: doc });
+    this.emit(EVENTS.USER_ADDED, { teamDid, user: doc });
 
     return doc;
   }
@@ -110,7 +110,7 @@ class TeamAPI extends EventEmitter {
     const doc = await state.update(user);
 
     logger.info('user updated successfully', { teamDid, userDid: user.did });
-    this.emit('user.updated', { teamDid, user: doc });
+    this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc });
 
     return doc;
   }
@@ -132,7 +132,7 @@ class TeamAPI extends EventEmitter {
 
     logger.info('user removed successfully', { teamDid, userDid: did });
 
-    this.emit('user.removed', { teamDid, user: { did } });
+    this.emit(EVENTS.USER_REMOVED, { teamDid, user: { did } });
 
     return { did };
   }
@@ -153,7 +153,7 @@ class TeamAPI extends EventEmitter {
 
     logger.info('user approval updated successfully', { teamDid, userDid: user.did, approved: user.approved });
 
-    this.emit('user.updated', { teamDid, user: doc2 });
+    this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc2 });
 
     return doc2;
   }
@@ -172,7 +172,7 @@ class TeamAPI extends EventEmitter {
 
     logger.info('user role updated successfully', { teamDid, userDid: user.did, role: user.role });
 
-    this.emit('user.updated', { teamDid, user: doc });
+    this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc });
 
     return doc;
   }
@@ -188,7 +188,7 @@ class TeamAPI extends EventEmitter {
 
     logger.info('user passport revoked successfully', { teamDid, userDid, passportId });
 
-    this.emit('user.updated', { teamDid, user: doc });
+    this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc });
 
     return doc;
   }
@@ -204,7 +204,7 @@ class TeamAPI extends EventEmitter {
 
     logger.info('user passport enabled successfully', { teamDid, userDid, passportId });
 
-    this.emit('user.updated', { teamDid, user: doc });
+    this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc });
 
     return doc;
   }

package/lib/blocklet/manager/disk.js

@@ -1075,16 +1075,9 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async getBlockletInterfaces({ blocklet, nodeInfo, context }) {
-    const routingRules = (await this.getRoutingRulesByDid(blocklet.meta.did)).sort((a, b) => {
-      // Put user-defined rules first
-      if (a.isProtected !== b.isProtected) {
-        return a.isProtected ? 1 : -1;
-      }
-      // Put shorter url first
-      return a.from.pathPrefix.length < b.from.pathPrefix ? 1 : -1;
-    });
+    const routingRules = await this.getRoutingRulesByDid(blocklet.meta.did);
     const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
-    return getBlockletInterfaces({ blocklet, context, nodeInfo, routingRules, nodeIp });
+    return getBlockletInterfaces({ blocklet, context, routingRules, nodeIp });
   }
 
   async attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
@@ -1267,17 +1260,20 @@ class BlockletManager extends BaseBlockletManager {
     this.emit(BlockletEvents.statusChange, state);
 
     try {
-      await this._installBlocklet({
+      const installedBlocklet = await this._installBlocklet({
         did,
         context,
       });
 
       if (context.startImmediately) {
-        try {
-          logger.info('start blocklet after installed', { did });
-          await this.start({ did, checkHealthImmediately: true });
-        } catch (error) {
-          logger.warn('attempt to start immediately failed', { did, error });
+        const missingProps = getRequiredMissingConfigs(installedBlocklet);
+        if (!missingProps.length) {
+          try {
+            logger.info('start blocklet after installed', { did });
+            await this.start({ did, checkHealthImmediately: true });
+          } catch (error) {
+            logger.warn('attempt to start immediately failed', { did, error });
+          }
         }
       }
     } catch (err) {

package/lib/event.js

@@ -1,10 +1,10 @@
 const get = require('lodash/get');
 const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
-const { BLOCKLET_MODES } = require('@blocklet/meta/lib/constants');
 const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
-const { BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/meta/lib/constants');
+const { BLOCKLET_MODES, BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/meta/lib/constants');
+const { EVENTS } = require('@abtnode/constant');
 
 const eventHub =
   process.env.NODE_ENV === 'test' ? require('@arcblock/event-hub/single') : require('@arcblock/event-hub');
@@ -43,6 +43,15 @@ module.exports = ({
     originEmit(name, ...args);
   };
 
+  // Subscribe events from eventHub and proxy to eventHandler
+  [...Object.values(BlockletEvents), ...Object.values(EVENTS)].forEach((name) => {
+    eventHub.on(name, (data) => {
+      if (typeof eventHandler === 'function') {
+        eventHandler({ name, data });
+      }
+    });
+  });
+
   let eventHandler = null;
 
   const onEvent = (name, data) => {
@@ -51,9 +60,6 @@ module.exports = ({
       safeData = wipeSensitiveData(cloneDeep(data));
     }
     events.emit(name, safeData);
-    if (typeof eventHandler === 'function') {
-      eventHandler({ name, data: safeData });
-    }
   };
 
   const handleBlockletAdd = async (name, { blocklet, context }) => {
@@ -79,8 +85,6 @@ module.exports = ({
         severity: 'error',
       });
     }
-
-    onEvent(name, blocklet);
   };
 
   const handleBlockletRemove = async (name, { blocklet, context }) => {
@@ -103,8 +107,6 @@ module.exports = ({
     } catch (error) {
       logger.error('prune blocklet app folder error', { event: name, error });
     }
-
-    onEvent(name, blocklet);
   };
 
   const handleBlockletUpgrade = async (name, { blocklet, context }) => {
@@ -128,8 +130,6 @@ module.exports = ({
     } catch (error) {
       logger.error('prune blocklet app folder error', { event: name, error });
     }
-
-    onEvent(name, blocklet);
   };
 
   const handleServerEvent = (eventName) => {
@@ -142,6 +142,22 @@ module.exports = ({
     });
   };
 
+  const handleBlockletEvent = async (eventName, payload) => {
+    if ([BlockletEvents.deployed, BlockletEvents.installed].includes(eventName)) {
+      await handleBlockletAdd(eventName, payload);
+    } else if ([BlockletEvents.upgraded, BlockletEvents.downgraded].includes(eventName)) {
+      await handleBlockletUpgrade(eventName, payload);
+    } else if ([BlockletEvents.removed].includes(eventName)) {
+      await handleBlockletRemove(eventName, payload);
+    }
+
+    if (payload.blocklet && !payload.meta) {
+      onEvent(eventName, payload.blocklet);
+    } else {
+      onEvent(eventName, payload);
+    }
+  };
+
   const downloadAddedBlocklet = async () => {
     try {
       const blocklets = await states.blocklet.find({
@@ -158,25 +174,17 @@ module.exports = ({
     }
   };
 
-  blockletManager.on(BlockletEvents.statusChange, (data) => onEvent(BlockletEvents.statusChange, data));
-  blockletManager.on(BlockletEvents.added, (data) => onEvent(BlockletEvents.added, data));
-  blockletManager.on(BlockletEvents.installed, (data) => handleBlockletAdd(BlockletEvents.installed, data));
-  blockletManager.on(BlockletEvents.installFailed, (data) => onEvent(BlockletEvents.installFailed, data));
-  blockletManager.on(BlockletEvents.deployed, (data) => handleBlockletAdd(BlockletEvents.deployed, data));
-  blockletManager.on(BlockletEvents.started, (data) => onEvent(BlockletEvents.started, data));
-  blockletManager.on(BlockletEvents.startFailed, (data) => onEvent(BlockletEvents.startFailed, data));
-  blockletManager.on(BlockletEvents.reloaded, (data) => onEvent(BlockletEvents.reloaded, data));
-  blockletManager.on(BlockletEvents.updated, (data) => onEvent(BlockletEvents.updated, data));
-  blockletManager.on(BlockletEvents.downloadFailed, (data) => onEvent(BlockletEvents.downloadFailed, data));
-  blockletManager.on(BlockletEvents.upgraded, (data) => handleBlockletUpgrade(BlockletEvents.upgraded, data));
-  blockletManager.on(BlockletEvents.downgraded, (data) => handleBlockletUpgrade(BlockletEvents.downgraded, data));
-  blockletManager.on(BlockletEvents.removed, (data) => handleBlockletRemove(BlockletEvents.removed, data));
-  notificationState.on('notification.create', (data) => onEvent('notification.create', data));
+  Object.values(BlockletEvents).forEach((eventName) => {
+    blockletManager.on(eventName, (data) => handleBlockletEvent(eventName, data));
+  });
+
+  notificationState.on(EVENTS.NOTIFICATION_CREATE, (data) => onEvent(EVENTS.NOTIFICATION_CREATE, data));
+
   nodeState.on(BlockletEvents.purchaseChange, (data) => onEvent(BlockletEvents.purchaseChange, data));
-  nodeState.on('routing.updated', (nodeInfo) => onEvent('routing.updated', { routing: nodeInfo.routing }));
-  nodeState.once('node.addedOwner', () => downloadAddedBlocklet());
-  nodeState.on('node.updated', (nodeInfo, oldInfo) => {
-    onEvent('node.updated', { did: nodeInfo.did });
+  nodeState.on(EVENTS.ROUTING_UPDATED, (nodeInfo) => onEvent(EVENTS.ROUTING_UPDATED, { routing: nodeInfo.routing }));
+  nodeState.once(EVENTS.NODE_ADDED_OWNER, () => downloadAddedBlocklet());
+  nodeState.on(EVENTS.NODE_UPDATED, (nodeInfo, oldInfo) => {
+    onEvent(EVENTS.NODE_UPDATED, { did: nodeInfo.did });
     blockletRegistry
       .refreshBlocklets()
       .catch((error) => logger.error('refresh blocklets failed on initialize the registry', { error }));
@@ -190,15 +198,17 @@ module.exports = ({
       });
     }
   });
-  nodeState.on('node.upgrade.progress', (session) => onEvent('node.upgrade.progress', session));
-  domainStatus.on('domain.status', (data) => {
+  nodeState.on(EVENTS.NODE_UPGRADE_PROGRESS, (session) => onEvent(EVENTS.NODE_UPGRADE_PROGRESS, session));
+
+  domainStatus.on(EVENTS.DOMAIN_STATUS, (data) => {
     if (data) {
-      onEvent('domain.status', data);
+      onEvent(EVENTS.DOMAIN_STATUS, data);
     }
   });
-  teamAPI.on('user.added', (data) => onEvent('user.added', data));
-  teamAPI.on('user.removed', (data) => onEvent('user.removed', data));
-  teamAPI.on('user.updated', (data) => onEvent('user.updated', data));
+
+  teamAPI.on(EVENTS.USER_ADDED, (data) => onEvent(EVENTS.USER_ADDED, data));
+  teamAPI.on(EVENTS.USER_REMOVED, (data) => onEvent(EVENTS.USER_REMOVED, data));
+  teamAPI.on(EVENTS.USER_UPDATED, (data) => onEvent(EVENTS.USER_UPDATED, data));
   teamAPI.on(BlockletEvents.updated, (data) => onEvent(BlockletEvents.updated, data));
 
   events.setEventHandler = (handler) => {
@@ -207,11 +217,8 @@ module.exports = ({
     }
   };
 
-  events.handleBlockletAdd = handleBlockletAdd;
-  events.handleBlockletUpgrade = handleBlockletUpgrade;
-  events.handleBlockletRemove = handleBlockletRemove;
   events.handleServerEvent = handleServerEvent;
-  events.onEvent = onEvent;
+  events.handleBlockletEvent = handleBlockletEvent;
 
   return events;
 };

package/lib/index.js

@@ -11,7 +11,7 @@ const {
   toBlockletSource,
 } = require('@blocklet/meta/lib/constants');
 const { listProviders } = require('@abtnode/router-provider');
-const { DEFAULT_CERTIFICATE_EMAIL } = require('@abtnode/constant');
+const { DEFAULT_CERTIFICATE_EMAIL, EVENTS } = require('@abtnode/constant');
 
 const RoutingSnapshot = require('./states/routing-snapshot');
 const BlockletRegistry = require('./blocklet/registry');
@@ -408,14 +408,14 @@ function ABTNode(options) {
       initCron();
     } else {
       // We should only respond to pm2 events when node is alive
-      events.on('node.started', async () => {
+      events.on(EVENTS.NODE_STARTED, async () => {
         pm2Events.resume();
         initCron();
       });
     }
   }
 
-  events.on('node.stopped', () => {
+  events.on(EVENTS.NODE_STOPPED, () => {
     pm2Events.pause();
   });
 

package/lib/router/helper.js

@@ -16,7 +16,7 @@ const {
   DOMAIN_FOR_IP_SITE_REGEXP,
   DOMAIN_FOR_INTERNAL_SITE,
   WELLKNOWN_PATH_PREFIX,
-  WELLKNOWN_AUTH_PATH_PREFIX,
+  WELLKNOWN_SERVICE_PATH_PREFIX,
   DOMAIN_FOR_IP_SITE,
   NAME_FOR_WELLKNOWN_SITE,
   DEFAULT_HTTP_PORT,
@@ -49,7 +49,6 @@ const {
   findInterfacePortByName,
   getWellknownSitePort,
 } = require('../util');
-const { getServicesFromBlockletInterface } = require('../util/service');
 const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
@@ -144,7 +143,7 @@ const attachInterfaceUrls = async ({ sites = [], context, node }) => {
               ruleId,
               type: x.type,
               name: x.name,
-              url: getInterfaceUrl({ baseUrl, url: '/', version: blocklet.meta.version }),
+              url: getInterfaceUrl({ baseUrl, url: '/' }),
             });
           }
         });
@@ -280,9 +279,9 @@ const ensureLatestInterfaceInfo = async (sites = []) => {
     }
 
     site.rules = site.rules.map((rule) => {
-      // If a rule already has a target and target is WELLKNOWN_AUTH_PATH_PREFIX, just return
+      // If a rule already has a target and target is WELLKNOWN_SERVICE_PATH_PREFIX, just return
       // Indicates that the rule id generated by the system for auth service
-      if (rule.isProtected && rule.to.target === WELLKNOWN_AUTH_PATH_PREFIX) {
+      if (rule.isProtected && rule.to.target === WELLKNOWN_SERVICE_PATH_PREFIX) {
         return rule;
       }
 
@@ -325,7 +324,7 @@ const ensureWellknownRule = async (sites) => {
         });
       }
 
-      // add /.well-known/auth for blocklet
+      // add /.well-known/service for blocklet
       const rules = cloneDeep(site.rules);
       rules.forEach((rule) => {
         if (
@@ -336,11 +335,11 @@ const ensureWellknownRule = async (sites) => {
         }
 
         // already exists
-        if (rule.from.pathPrefix.endsWith(WELLKNOWN_AUTH_PATH_PREFIX)) {
+        if (rule.from.pathPrefix.endsWith(WELLKNOWN_SERVICE_PATH_PREFIX)) {
           return;
         }
 
-        const pathPrefix = joinUrl(rule.from.pathPrefix, WELLKNOWN_AUTH_PATH_PREFIX);
+        const pathPrefix = joinUrl(rule.from.pathPrefix, WELLKNOWN_SERVICE_PATH_PREFIX);
 
         // already exists
         if (site.rules.some((x) => x.from.pathPrefix === pathPrefix)) {
@@ -348,8 +347,6 @@ const ensureWellknownRule = async (sites) => {
         }
 
         rule.from.pathPrefix = pathPrefix;
-        // let service gateway keep WELLKNOWN_AUTH_PATH_PREFIX prefix
-        rule.to.target = WELLKNOWN_AUTH_PATH_PREFIX;
         rule.isProtected = true;
         site.rules.push(rule);
       });
@@ -389,43 +386,6 @@ const ensureLatestInfo = async (sites = [], { withDefaultCors = true } = {}) =>
   return ensureLatestInterfaceInfo(result);
 };
 
-const ensureAuthService = async (sites = [], blockletManager) => {
-  const blocklets = await blockletManager.list({ includeRuntimeInfo: false });
-  const blockletMap = blocklets.reduce((o, x) => {
-    o[x.meta.did] = x;
-    return o;
-  }, {});
-
-  sites.forEach((site) => {
-    site.rules.forEach((rule) => {
-      if (rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET || !blockletMap[rule.to.did]) {
-        return;
-      }
-
-      // find blocklet
-      let blocklet = blockletMap[rule.to.did];
-      if (rule.to.realDid && rule.to.did !== rule.to.realDid) {
-        blocklet = (blocklet.children || []).find((x) => x.meta.did === rule.to.realDid);
-      }
-      if (!blocklet) {
-        return;
-      }
-
-      // find interface
-      // 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 === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
-      if (_interface) {
-        rule.services = rule.services || [];
-        rule.services.unshift(...getServicesFromBlockletInterface(_interface, { logError: logger.error }));
-      }
-    });
-  });
-
-  return sites;
-};
-
 const decompressCertificates = async (source, dest) => {
   fs.ensureDirSync(dest);
   await tar.x({ file: source, C: dest });
@@ -600,7 +560,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
           response: {
             status: 200,
             contentType: 'application/javascript',
-            body: "console.log('ping: pong')",
+            body: "'pong'",
           },
           port: info.port,
         },
@@ -1154,7 +1114,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   async function getRoutingRulesByDid(did) {
     const info = await nodeState.read();
     const { sites } = await readRoutingSites();
-    const rules = Router.flattenSitesToRules(sites, info);
+    const domain = getBlockletDomainGroupName(did);
+    const rules = Router.flattenSitesToRules(
+      (sites || []).filter((x) => x.domain === domain),
+      info
+    );
     return rules.filter((rule) => rule.to.did === did);
   }
 
@@ -1186,7 +1150,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             let { sites } = await readRoutingSites();
             sites = await filterSitesForRemovedBlocklets(sites);
             sites = await ensureLatestInfo(sites);
-            sites = await ensureAuthService(sites, blockletManager);
             sites = await ensureServiceRule(sites);
             sites = await ensureRootRule(sites);
 

package/lib/states/node.js

@@ -6,7 +6,7 @@ const isEmpty = require('lodash/isEmpty');
 const security = require('@abtnode/util/lib/security');
 const { isFromPublicKey } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:node');
-const { NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT } = require('@abtnode/constant');
+const { NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT, EVENTS } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
@@ -164,7 +164,7 @@ class NodeState extends BaseState {
     const record = await this.read();
 
     const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft', 'sk']) });
-    this.emit('node.updated', updateResult, record);
+    this.emit(EVENTS.NODE_UPDATED, updateResult, record);
     return updateResult;
   }
 
@@ -174,7 +174,7 @@ class NodeState extends BaseState {
     }
 
     const nodeInfo = await this.updateNodeInfo({ routing: entity });
-    this.emit('routing.updated', nodeInfo);
+    this.emit(EVENTS.ROUTING_UPDATED, nodeInfo);
 
     return nodeInfo;
   }
@@ -221,7 +221,7 @@ class NodeState extends BaseState {
         $set: { nodeOwner: owner, initialized, initializedAt: initialized ? new Date() : null },
       });
 
-      this.emit('node.addedOwner', updateResult);
+      this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
 
       return updateResult;
     });

package/lib/states/notification.js

@@ -1,5 +1,6 @@
 const get = require('lodash/get');
 const logger = require('@abtnode/logger')('@abtnode/core:states:notification');
+const { EVENTS } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 
@@ -46,7 +47,7 @@ class NotificationState extends BaseState {
           }
 
           logger.info('create', { data });
-          this.emit('notification.create', data);
+          this.emit(EVENTS.NOTIFICATION_CREATE, data);
           return resolve(data);
         }
       );

package/lib/util/domain-status.js

@@ -1,5 +1,6 @@
 const { EventEmitter } = require('events');
 const logger = require('@abtnode/logger')('@abtnode/domain-status');
+const { EVENTS } = require('@abtnode/constant');
 const { checkDomainDNS } = require('./index');
 
 const dnsStatusStore = Object.create(null);
@@ -35,7 +36,7 @@ class DomainStatus extends EventEmitter {
       Promise.all([this.routerManager.getMatchedCert(domain), checkDomainDnsWrapper(domain)])
         .then((data) => {
           const [matchedCert, dns] = data;
-          this.emit('domain.status', { domain, matchedCert, isHttps: !!matchedCert, dns });
+          this.emit(EVENTS.DOMAIN_STATUS, { domain, matchedCert, isHttps: !!matchedCert, dns });
         })
         .catch((error) => {
           logger.error('check domain status error', { domain, error });

package/lib/util/index.js

@@ -12,7 +12,6 @@ const { isFromPublicKey } = require('@arcblock/did');
 const joinUrl = require('url-join');
 const { Certificate } = require('@fidm/x509');
 const getPortLib = require('get-port');
-const isIp = require('is-ip');
 const v8 = require('v8');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const parseBlockletMeta = require('@blocklet/meta/lib/parse');
@@ -30,13 +29,12 @@ const {
   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;
 
 const logger = require('@abtnode/logger')('@abtnode/core:util');
 
-const { getServices, getServicesFromBlockletInterface } = require('./service');
+const { getServices } = require('./service');
 const request = require('./request');
 
 const validateOwner = (owner) => {
@@ -53,7 +51,7 @@ const fromStatus = (v) => {
   return match ? match[0] : 'unknown';
 };
 
-const getInterfaceUrl = ({ baseUrl, url, version }) => {
+const getInterfaceUrl = ({ baseUrl, url }) => {
   if (!url) {
     return '';
   }
@@ -63,11 +61,6 @@ const getInterfaceUrl = ({ baseUrl, url, version }) => {
   }
 
   const parsed = new URL(joinUrl(baseUrl, url));
-  const params = parsed.searchParams;
-
-  if (version) {
-    params.set('__bv__', version);
-  }
 
   return parsed.href;
 };
@@ -112,104 +105,43 @@ const getBlockletHost = ({ domain, context, nodeIp }) => {
   return `${tmpDomain}:${port}`;
 };
 
-/**
- * Get config of auth service of blocklet component specified the routing rule
- * @param {*} rule routing rule
- * @param {*} blocklet
- * @returns
- */
-const getAuthConfig = (rule, blocklet) => {
-  if (!blocklet || !rule || rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET || rule.to.did !== blocklet.meta.did) {
-    return null;
-  }
-
-  // find blocklet component
-  const isRootRule = rule.to.did === rule.to.realDid;
-  let _blocklet;
-  if (isRootRule) {
-    _blocklet = blocklet;
-  } else {
-    _blocklet = (blocklet.children || []).find((x) => x.meta.did === rule.to.realDid);
-  }
-  if (!_blocklet) {
-    return null;
-  }
-
-  // find interface in meta
-  const interfaceName = rule.to.realInterfaceName;
-  const { interfaces } = _blocklet.meta;
-  const _interface = interfaces.find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
-
-  if (!_interface) {
-    return null;
-  }
-
-  // find auth service
-  const auth = getServicesFromBlockletInterface(_interface, { stringifyConfig: false }).find(
-    (x) => x.name === '@abtnode/auth-service'
-  );
-
-  if (!auth) {
-    return null;
+const getBlockletBaseUrls = ({ rules = [], context = {}, nodeIp }) => {
+  if (!Array.isArray(rules) || !rules.length) {
+    return [];
   }
 
-  return auth.config;
-};
-
-const getBlockletBaseUrls = ({ routingEnabled = false, port, rules = [], context = {}, blocklet, nodeIp }) => {
-  let baseUrls = [];
-
-  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)) {
-            protocol = 'https';
-          }
-
-          return {
-            ruleId: rule.id,
-            baseUrl: `${protocol}://${host}/${trimSlash(rule.from.pathPrefix)}`,
-            interfaceName: get(rule, 'to.interfaceName', ''),
-            authConfig: getAuthConfig(rule, blocklet),
-          };
+  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_DNS_DOMAIN_SUFFIX)) {
+          protocol = 'https';
         }
 
-        return null;
-      })
-      .filter(Boolean);
-  }
-
-  if (!baseUrls.length && isIp(context.hostname)) {
-    baseUrls = [{ baseUrl: `http://${context.hostname}:${port}` }];
-  }
+        return {
+          ruleId: rule.id,
+          baseUrl: `${protocol}://${host}/${trimSlash(rule.from.pathPrefix)}`,
+          interfaceName: get(rule, 'to.interfaceName', ''),
+        };
+      }
 
-  return baseUrls;
+      return null;
+    })
+    .filter(Boolean);
 };
 
-const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, nodeIp }) => {
+const getBlockletInterfaces = ({ blocklet, context, routingRules, nodeIp }) => {
   const interfaces = [];
-  (blocklet.meta.interfaces || []).forEach((x) => {
-    if (x.port && x.port.external) {
-      // If an interface was exposed through external port, path is not appended
-      const baseUrls = getBlockletBaseUrls({
-        routingEnabled: false,
-        port: x.port.external,
-        rules: [],
-        context,
-      });
-      baseUrls.forEach(({ baseUrl }) => interfaces.push({ type: x.type, name: x.name, url: baseUrl }));
-    } else {
+  (blocklet.meta.interfaces || [])
+    .filter((x) => !get(x, 'port.external'))
+    .forEach((x) => {
       // Otherwise, the url is composed with routing rules
-      const port = x.port && x.port.internal ? blocklet.ports[x.port.internal] : blocklet.ports[x.port];
       const baseUrls = getBlockletBaseUrls({
-        routingEnabled: isRoutingEnabled(nodeInfo.routing),
-        port,
         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
@@ -219,11 +151,10 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, node
           );
         }),
         context,
-        blocklet,
         nodeIp,
       });
 
-      baseUrls.forEach(({ baseUrl, ruleId, interfaceName, authConfig }) => {
+      baseUrls.forEach(({ baseUrl, ruleId, interfaceName }) => {
         if (interfaceName && interfaceName !== x.name) {
           return;
         }
@@ -231,12 +162,10 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, node
           ruleId,
           type: x.type,
           name: x.name,
-          url: getInterfaceUrl({ baseUrl, url: '/', version: blocklet.meta.version }),
-          authConfig,
+          url: getInterfaceUrl({ baseUrl, url: '/' }),
         });
       });
-    }
-  });
+    });
 
   return uniqBy(interfaces, 'url');
 };

package/lib/util/service.js

@@ -1,51 +1,67 @@
 const fs = require('fs-extra');
+const cloneDeep = require('lodash/cloneDeep');
+const Ajv = require('ajv').default;
 
-const getServices = ({ stringifySchema = false } = {}) =>
-  ['auth']
-    .map((x) => {
-      let service;
-
-      try {
-        const metaFile = require.resolve(`@abtnode/blocklet-services/services/${x}/meta.json`);
-        service = fs.readJSONSync(metaFile);
-      } catch (err) {
-        service = {};
-      }
-
-      if (stringifySchema) {
-        service.schema = JSON.stringify(service.schema);
-      }
-
-      return service;
-    })
-    .filter((x) => x.name && x.version);
-
-const getServicesFromBlockletInterface = (
-  interfaceMeta,
-  { logError, services = getServices(), stringifyConfig = true } = {}
-) => {
-  const list = interfaceMeta.services || [];
-  return list
-    .map((s) => {
-      const service = services.find((t) => t.name === s.name);
-
-      if (!service) {
-        if (typeof logError === 'function') {
-          logError('Service in blocklet meta was not found in node');
-        }
-        return null;
-      }
-
-      const { name, version, description } = service;
-
-      const config = stringifyConfig ? JSON.stringify(s.config) : s.config;
-
-      return { name, version, description, config };
-    })
-    .filter(Boolean);
+const ajv = new Ajv({
+  useDefaults: true,
+  removeAdditional: 'all',
+});
+
+const SERVICES = {
+  AUTH: fs.readJSONSync(require.resolve('@abtnode/blocklet-services/configs/auth.json')),
+};
+
+const getServices = ({ stringifySchema = false } = {}) => {
+  const list = Object.values(SERVICES).map((x) => {
+    const data = cloneDeep(x);
+    if (stringifySchema) {
+      data.schema = JSON.stringify(x.schema);
+    }
+    return data;
+  });
+
+  // backward compatible
+  const authService = cloneDeep(list.find((x) => x.name === 'auth'));
+  authService.name = '@abtnode/auth-service';
+  list.push(authService);
+
+  return list;
+};
+
+const getServiceMeta = (serviceName) => {
+  if (!serviceName) {
+    throw new Error('service name should not be empty');
+  }
+  const metas = getServices();
+  const meta = metas.find((x) => x.name === serviceName);
+  if (!meta) {
+    throw new Error(`service ${serviceName} does not exist`);
+  }
+
+  return meta;
+};
+
+const getServiceConfig = (service, customConfig) => {
+  const serviceMeta = typeof service === 'string' ? getServiceMeta(service) : service;
+
+  const validate = ajv.compile(serviceMeta.schema.JSONSchema);
+
+  const data = cloneDeep(customConfig || {});
+  // this method may have side effect thar will fill default value to customConfig
+  validate(data || {});
+
+  return data;
+};
+
+const getDefaultServiceConfig = (service) => {
+  const serviceMeta = typeof service === 'string' ? getServiceMeta(service) : service;
+
+  // parse empty custom config to get default config
+  return getServiceConfig(serviceMeta, {});
 };
 
 module.exports = {
   getServices,
-  getServicesFromBlockletInterface,
+  getServiceConfig,
+  getDefaultServiceConfig,
 };

package/lib/util/sysinfo.js

@@ -1,18 +1,29 @@
 const EventEmitter = require('events');
-const driveList = require('drivelist');
-const si = require('systeminformation');
-const checkDiskSpace = require('check-disk-space').default;
+const maxBy = require('lodash/maxBy');
+const SysInfo = require('systeminformation');
 
 const getSysInfo = async () => {
-  const [info, drives] = await Promise.all([
-    si.get({
-      cpu: 'physicalCores',
-      mem: '*',
-      currentLoad: '*',
-      osInfo: 'platform',
-    }),
-    driveList.list(),
-  ]);
+  const info = await SysInfo.get({
+    cpu: 'physicalCores',
+    mem: '*',
+    currentLoad: '*',
+    fsSize: '*',
+    diskLayout: '*',
+    osInfo: 'platform',
+  });
+
+  let drives = info.fsSize;
+  if (info.osInfo.platform === 'darwin') {
+    const systemDrives = (info.fsSize || []).filter((x) => x.type === 'APFS');
+    const rootDrive = systemDrives.find((x) => x.mount === '/');
+    if (rootDrive) {
+      const maxUsedDrive = maxBy(systemDrives, (x) => x.used);
+      rootDrive.used = maxUsedDrive.used;
+      drives = [rootDrive];
+    } else {
+      drives = [];
+    }
+  }
 
   return {
     cpu: {
@@ -21,20 +32,13 @@ const getSysInfo = async () => {
     },
     mem: info.mem,
     os: info.osInfo,
-    disks: await Promise.all(
-      drives
-        .filter((x) => x.isSystem && x.isVirtual === false && x.mountpoints.length)
-        .map(async (x) => {
-          const result = await checkDiskSpace(x.mountpoints[0].path);
-          return {
-            device: x.device,
-            mountPoint: result.diskPath,
-            total: result.size,
-            used: result.size - result.free,
-            free: result.free,
-          };
-        })
-    ),
+    disks: drives.map((x) => ({
+      device: x.fs,
+      mountPoint: x.mount,
+      total: x.size,
+      used: x.used,
+      free: x.size - x.used,
+    })),
   };
 };
 

package/lib/util/upgrade.js

@@ -2,7 +2,7 @@
 const axon = require('axon');
 const semver = require('semver');
 const sleep = require('@abtnode/util/lib/sleep');
-const { NODE_MODES, NODE_UPGRADE_PROGRESS } = require('@abtnode/constant');
+const { NODE_MODES, NODE_UPGRADE_PROGRESS, EVENTS } = require('@abtnode/constant');
 const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
 const Lock = require('@abtnode/util/lib/lock');
 const logger = require('@abtnode/logger')('@abtnode/core:upgrade');
@@ -108,7 +108,7 @@ const doUpgrade = async (session) => {
   const goNextState = async (stage) => {
     session = await states.session.update(sessionId, { stage });
     // Emit events so client will keep up
-    states.node.emit('node.upgrade.progress', session);
+    states.node.emit(EVENTS.NODE_UPGRADE_PROGRESS, session);
   };
 
   // 1. enter maintenance mode

package/lib/webhook/index.js

@@ -1,6 +1,7 @@
 const logger = require('@abtnode/logger')('@abtnode/core:webhook:index');
 
 const sortPriorityUrl = require('@abtnode/util/lib/sort-priority-url');
+const { EVENTS } = require('@abtnode/constant');
 const WebHookSender = require('./sender');
 const createQueue = require('../queue');
 const IP = require('../util/ip');
@@ -105,15 +106,15 @@ module.exports = ({ events, dataDirs, instance }) => {
     },
   });
 
-  events.on('notification.create', (data) => {
+  events.on(EVENTS.NOTIFICATION_CREATE, (data) => {
     const { title, description, severity, action, entityType } = data;
     queue.push({ title, description, status: severity, action, entityType });
   });
 
-  events.on('node.started', async (message) => {
+  events.on(EVENTS.NODE_STARTED, async (message) => {
     await sendMessage(message);
   });
-  events.on('node.stopped', async (message) => {
+  events.on(EVENTS.NODE_STOPPED, async (message) => {
     await sendMessage(message);
   });
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.25",
+  "version": "1.6.28",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,22 +19,22 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/certificate-manager": "1.6.25",
-    "@abtnode/constant": "1.6.25",
-    "@abtnode/cron": "1.6.25",
-    "@abtnode/db": "1.6.25",
-    "@abtnode/logger": "1.6.25",
-    "@abtnode/queue": "1.6.25",
-    "@abtnode/rbac": "1.6.25",
-    "@abtnode/router-provider": "1.6.25",
-    "@abtnode/static-server": "1.6.25",
-    "@abtnode/timemachine": "1.6.25",
-    "@abtnode/util": "1.6.25",
+    "@abtnode/certificate-manager": "1.6.28",
+    "@abtnode/constant": "1.6.28",
+    "@abtnode/cron": "1.6.28",
+    "@abtnode/db": "1.6.28",
+    "@abtnode/logger": "1.6.28",
+    "@abtnode/queue": "1.6.28",
+    "@abtnode/rbac": "1.6.28",
+    "@abtnode/router-provider": "1.6.28",
+    "@abtnode/static-server": "1.6.28",
+    "@abtnode/timemachine": "1.6.28",
+    "@abtnode/util": "1.6.28",
     "@arcblock/did": "^1.14.19",
     "@arcblock/event-hub": "1.14.19",
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/vc": "^1.14.19",
-    "@blocklet/meta": "1.6.25",
+    "@blocklet/meta": "1.6.28",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
@@ -42,13 +42,12 @@
     "@ocap/util": "^1.14.19",
     "@ocap/wallet": "^1.14.19",
     "@slack/webhook": "^5.0.3",
+    "ajv": "^7.0.3",
     "axios": "^0.25.0",
     "axon": "^2.0.3",
     "chalk": "^4.0.0",
-    "check-disk-space": "^3.2.0",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.3.0",
-    "drivelist": "^9.2.4",
     "flat": "^5.0.2",
     "fs-extra": "^10.0.0",
     "get-port": "^5.1.1",
@@ -78,5 +77,5 @@
     "express": "^4.17.1",
     "jest": "^27.4.5"
   },
-  "gitHead": "bd2ad7d90fbd1b3786702dfca1ab28dcec9a7bc7"
+  "gitHead": "acef8ea339bd8fc9c785312eb5a1a113ecbf0d4d"
 }