@abtnode/core 1.16.13-beta-0656f92f → 1.16.13-beta-2eb54cbc

package/lib/blocklet/manager/disk.js

@@ -116,6 +116,7 @@ const {
   getBlockletStatus,
   shouldSkipComponent,
   exceedRedemptionPeriod,
+  ensureAppPortsNotOccupied,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
@@ -457,40 +458,66 @@ class BlockletManager extends BaseBlockletManager {
     return { did, isInstalled: !!blocklet, isRunning };
   }
 
-  async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false, componentDids }, context) {
+  async start(
+    { did, throwOnError, checkHealthImmediately = false, e2eMode = false, componentDids: inputComponentDids, atomic },
+    context
+  ) {
+    const blocklet = await this.ensureBlocklet(did, { e2eMode });
+
+    if (atomic || !blocklet.structVersion) {
+      return this._start(
+        { did, throwOnError, checkHealthImmediately, e2eMode, componentDids: inputComponentDids },
+        context
+      );
+    }
+
+    const componentDids = inputComponentDids?.length ? inputComponentDids : blocklet.children.map((x) => x.meta.did);
+
+    const tasks = componentDids.map((componentDid) =>
+      this._start({ did, throwOnError, checkHealthImmediately, e2eMode, componentDids: [componentDid] }, context)
+    );
+
+    return Promise.any(tasks).catch((err) => {
+      throw new Error(err.errors.join(', '));
+    });
+  }
+
+  async _start(
+    { blocklet: inputBlocklet, did, throwOnError, checkHealthImmediately = false, e2eMode = false, componentDids },
+    context
+  ) {
     logger.info('start blocklet', { did, componentDids, throwOnError, checkHealthImmediately, e2eMode });
     // should check blocklet integrity
-    const blocklet = await this.ensureBlocklet(did, { e2eMode });
+    const blocklet1 = inputBlocklet || (await this.ensureBlocklet(did, { e2eMode }));
 
-    await this.checkControllerStatus(blocklet, 'start');
+    await this.checkControllerStatus(blocklet1, 'start');
+
+    // validate requirement and engine
+    await validateBlocklet(blocklet1);
+    await validateBlockletChainInfo(blocklet1);
+
+    if (!hasRunnableComponent(blocklet1)) {
+      throw new Error('No runnable component found');
+    }
+
+    // check required config
+    const missingProps = getAppMissingConfigs(blocklet1);
+    if (missingProps.length) {
+      throw new Error(
+        `Missing required configuration to start the blocklet: ${missingProps.map((x) => x.key).join(',')}`
+      );
+    }
 
     try {
       // blocklet may be manually stopped durning starting
       // so error message would not be sent if blocklet is stopped
       // so we need update status first
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, { componentDids });
-      blocklet.status = BlockletStatus.starting;
+      const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, { componentDids });
+      blocklet1.status = BlockletStatus.starting;
+      this.emit(BlockletEvents.statusChange, doc1);
 
-      // validate requirement and engine
-      await validateBlocklet(blocklet);
-      await validateBlockletChainInfo(blocklet);
-
-      if (!hasRunnableComponent(blocklet)) {
-        throw new Error('No runnable component found');
-      }
-
-      // check required config
-      const missingProps = getAppMissingConfigs(blocklet);
-      if (missingProps.length) {
-        throw new Error(
-          `Missing required configuration to start the blocklet: ${missingProps.map((x) => x.key).join(',')}`
-        );
-      }
-
-      this.emit(BlockletEvents.statusChange, blocklet);
-
-      if (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT) {
-        const { logsDir } = blocklet.env;
+      if (blocklet1.mode === BLOCKLET_MODES.DEVELOPMENT) {
+        const { logsDir } = blocklet1.env;
 
         try {
           fs.removeSync(logsDir);
@@ -501,6 +528,8 @@ class BlockletManager extends BaseBlockletManager {
         }
       }
 
+      const blocklet = await ensureAppPortsNotOccupied({ blocklet: blocklet1, componentDids, states, manager: this });
+
       const getHookFn =
         (hookName) =>
         (b, { env }) =>
@@ -554,8 +583,8 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       const error = Array.isArray(err) ? err[0] : err;
-      logger.error('Failed to start blocklet', { error, did, name: blocklet.meta.name });
-      const description = `Start blocklet ${blocklet.meta.title} failed with error: ${error.message}`;
+      logger.error('Failed to start blocklet', { error, did, title: blocklet1.meta.title });
+      const description = `Start blocklet ${blocklet1.meta.title} failed with error: ${error.message}`;
       this._createNotification(did, {
         title: 'Start Blocklet Failed',
         description,
@@ -567,6 +596,7 @@ class BlockletManager extends BaseBlockletManager {
       await this.deleteProcess({ did, componentDids });
       const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
       this.emit(BlockletEvents.startFailed, { ...res, error: { message: error.message } });
+      this.emit(BlockletEvents.statusChange, { ...res, error: { message: error.message } });
 
       if (throwOnError) {
         throw new Error(description);
@@ -583,9 +613,9 @@ class BlockletManager extends BaseBlockletManager {
     const { processId } = blocklet.env;
 
     if (updateStatus) {
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids });
+      const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids });
       blocklet.status = BlockletStatus.stopping;
-      this.emit(BlockletEvents.statusChange, blocklet);
+      this.emit(BlockletEvents.statusChange, doc);
     }
 
     try {
@@ -1992,6 +2022,7 @@ class BlockletManager extends BaseBlockletManager {
         components: getComponentsInternalInfo(res),
       });
 
+      this.emit(BlockletEvents.statusChange, res);
       this.emit(BlockletEvents.started, res);
       logger.info('blocklet healthy', { did, name, time: Date.now() - startedAt });
     } catch (error) {
@@ -2004,7 +2035,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('check blocklet if started failed', { did, name, context, timeout, error });
 
       await this.deleteProcess({ did, componentDids }, context);
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
+      const doc = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
 
       this._createNotification(did, {
         title: 'Blocklet Start Failed',
@@ -2015,6 +2046,7 @@ class BlockletManager extends BaseBlockletManager {
       });
 
       this.emit(BlockletEvents.startFailed, { meta, error });
+      this.emit(BlockletEvents.statusChange, { ...doc, error });
 
       if (throwOnError) {
         throw error;

package/lib/index.js

@@ -411,6 +411,9 @@ function ABTNode(options) {
       return states.auditLog.findPaginated.call(states.auditLog, params);
     },
 
+    // Insights
+    getTrafficInsights: states.trafficInsight.findPaginated.bind(states.trafficInsight),
+
     // Routing
     routerManager,
     addRoutingSite,

package/lib/router/helper.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const tar = require('tar');
 const UUID = require('uuid');
+const dayjs = require('@abtnode/util/lib/dayjs');
 const isUrl = require('is-url');
 const get = require('lodash/get');
 const cloneDeep = require('lodash/cloneDeep');
@@ -18,6 +19,7 @@ const downloadFile = require('@abtnode/util/lib/download-file');
 const { updateBlockletDocument } = require('@abtnode/util/lib/did-document');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 const { forEachBlockletSync } = require('@blocklet/meta/lib/util');
+const { processLogByDate } = require('@abtnode/analytics');
 const {
   DOMAIN_FOR_DEFAULT_SITE,
   DOMAIN_FOR_IP_SITE_REGEXP,
@@ -37,8 +39,10 @@ const {
   WELLKNOWN_ACME_CHALLENGE_PREFIX,
   WELLKNOWN_DID_RESOLVER_PREFIX,
   WELLKNOWN_PING_PREFIX,
+  WELLKNOWN_ANALYTICS_PREFIX,
   LOG_RETAIN_IN_DAYS,
   EVENTS,
+  DEFAULT_IP_DOMAIN,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
@@ -51,8 +55,9 @@ const {
   BLOCKLET_MODES,
 } = require('@blocklet/constant');
 
-// eslint-disable-next-line global-require
-const logger = require('@abtnode/logger')(`${require('../../package.json').name}:router:helper`);
+const pkg = require('../../package.json');
+// eslint-disable-next-line
+const logger = require('@abtnode/logger')(`${pkg.name}:router:helper`);
 const {
   getProviderFromNodeInfo,
   getHttpsCertInfo,
@@ -69,39 +74,79 @@ const Router = require('./index');
 const states = require('../states');
 const { getBlockletDomainGroupName, getDidFromDomainGroupName } = require('../util/router');
 const { getBlockletKnownAs, getBlockletDidDomainList } = require('../util/blocklet');
+const { toCamelCase } = require('../util/index');
+const { get: getIp } = require('../util/ip');
 
 const isServiceFeDevelopment = process.env.ABT_NODE_SERVICE_FE_PORT;
 
 const hasRuleByPrefix = (site, value) => site.rules.find((x) => x.isProtected && get(x, 'from.pathPrefix') === value);
 
+const pingWellknownRule = {
+  isProtected: true,
+  from: { pathPrefix: WELLKNOWN_PING_PREFIX },
+  to: {
+    type: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
+    response: {
+      status: 200,
+      contentType: 'application/javascript',
+      body: "'pong'",
+    },
+  },
+};
+
+const analyticsWellknownRule = {
+  isProtected: true,
+  from: { pathPrefix: WELLKNOWN_ANALYTICS_PREFIX },
+  to: {
+    type: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
+    response: {
+      status: 200,
+      contentType: 'text/html',
+      body: pkg.version,
+    },
+  },
+};
+
 /**
  * replace 888-888-888-888 with accessible ip for domain
  */
-const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) => {
+const attachRuntimeDomainAliases = async ({ sites = [], context = {} }) => {
   if (!sites) {
     return [];
   }
 
   let ip;
   const ipRegex = /\d+[-.]\d+[-.]\d+[-.]\d+/;
-  const match = ipRegex.exec(context.hostname);
+  const match = ipRegex.exec(context.hostname || '');
   if (match) {
     ip = match[0];
-  } else if (node) {
-    const nodeInfo = await node.read();
-    const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+  } else {
+    const nodeIp = await getAccessibleExternalNodeIp();
     if (nodeIp) {
       ip = nodeIp;
     }
   }
 
+  if (!ip) {
+    const result = await getIp();
+    if (result) {
+      ip = result.internal;
+    }
+  }
+
+  logger.info('attachRuntimeDomainAliases', { ip });
+
   const getDomainAliases = (site) =>
     (site.domainAliases || []).map((domain) => {
       if (!domain.value) {
         return domain;
       }
-      if (domain.value.includes(SLOT_FOR_IP_DNS_SITE) && ip) {
-        domain.value = replaceSlotToIp(domain.value, ip);
+      if (ip) {
+        if (domain.value.includes(SLOT_FOR_IP_DNS_SITE)) {
+          domain.value = replaceSlotToIp(domain.value, ip);
+        } else if (domain.value === DEFAULT_IP_DOMAIN) {
+          domain.value = `${ip.split('.').join('-')}${domain.value.substring(2)}`;
+        }
       }
       return domain;
     });
@@ -629,6 +674,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   const blockletState = states.blocklet;
   const siteState = states.site;
   const notification = states.notification;
+  const trafficInsight = states.trafficInsight;
 
   // site level duplication detection
 
@@ -778,46 +824,12 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         to: proxyTarget,
       };
 
-      const pingWellknownRule = {
-        isProtected: true,
-        from: { pathPrefix: WELLKNOWN_PING_PREFIX },
-        to: {
-          type: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
-          response: {
-            status: 200,
-            contentType: 'application/javascript',
-            body: "'pong'",
-          },
-          port: info.port,
-        },
-      };
-
       if (site) {
-        const didResolverRuleUpdateRes = await upsertSiteRule(
-          {
-            site,
-            rule: didResolverWellknownRule,
-          },
-          context
-        );
-
-        const acmeRuleUpdateRes = await upsertSiteRule(
-          {
-            site,
-            rule: acmeChallengeWellknownRule,
-          },
-          context
-        );
-
-        const pingRuleRes = await upsertSiteRule(
-          {
-            site,
-            rule: pingWellknownRule,
-          },
-          context
-        );
-
-        return didResolverRuleUpdateRes || acmeRuleUpdateRes || pingRuleRes;
+        const didResolverRuleUpdateRes = await upsertSiteRule({ site, rule: didResolverWellknownRule }, context);
+        const acmeRuleUpdateRes = await upsertSiteRule({ site, rule: acmeChallengeWellknownRule }, context);
+        const pingRuleRes = await upsertSiteRule({ site, rule: pingWellknownRule }, context);
+        const analyticsRuleRes = await upsertSiteRule({ site, rule: analyticsWellknownRule }, context);
+        return didResolverRuleUpdateRes || acmeRuleUpdateRes || pingRuleRes || analyticsRuleRes;
       }
 
       await routerManager.addRoutingSite(
@@ -826,7 +838,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             domain: DOMAIN_FOR_INTERNAL_SITE,
             port: await getWellknownSitePort(),
             name: NAME_FOR_WELLKNOWN_SITE,
-            rules: [didResolverWellknownRule, acmeChallengeWellknownRule, pingWellknownRule],
+            rules: [didResolverWellknownRule, acmeChallengeWellknownRule, pingWellknownRule, analyticsWellknownRule],
             isProtected: true,
           },
           skipCheckDynamicBlacklist: true,
@@ -893,13 +905,19 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     try {
       const result = await siteState.update({ id: dashboardSite.id }, { $set: { domainAliases } });
-
       updatedResult.push(result);
     } catch (error) {
       logger.error('add dashboard domain rule failed', { error });
       console.error('Add dashboard domain rule failed:', error);
     }
 
+    try {
+      const result = await upsertSiteRule({ site: dashboardSite, rule: analyticsWellknownRule }, context);
+      updatedResult.push(result);
+    } catch (error) {
+      logger.error('add dashboard analytics rule failed', { error });
+    }
+
     const defaultRule = sites.find((x) => x.domain === DOMAIN_FOR_DEFAULT_SITE);
     if (!defaultRule) {
       try {
@@ -1265,6 +1283,73 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     }
   };
 
+  const analyzeRouterLog = async () => {
+    const info = await nodeState.read();
+    const sites = await getRoutingSites({});
+    const providerName = get(info, 'routing.provider', null);
+    if (!providerName || !providers[providerName]) {
+      logger.warn('No router provider instance found');
+      return;
+    }
+
+    const groups = [];
+    const server = sites.find((x) =>
+      x.rules.some((rule) => rule.to.type === ROUTING_RULE_TYPES.DAEMON && rule.to.did === info.did)
+    );
+    if (server) {
+      groups.push({
+        did: info.did,
+        type: 'server',
+        hosts: server.domainAliases.map((d) => d.value).filter(Boolean),
+      });
+    }
+
+    // blocklets
+    sites
+      .filter((x) => x.domain.endsWith(BLOCKLET_SITE_GROUP_SUFFIX))
+      .forEach((site) => {
+        groups.push({
+          did: site.domain.replace(BLOCKLET_SITE_GROUP_SUFFIX, ''),
+          type: 'blocklet',
+          hosts: site.domainAliases.map((d) => d.value).filter(Boolean),
+        });
+      });
+    logger.info('Prepare analyze router logs', groups);
+
+    const logDir = providers[providerName].getLogDir();
+    const doAnalyze = async (date, groupsRaw) => {
+      logger.info('Start analyze router logs', { date });
+      try {
+        let results = await processLogByDate(logDir, dataDirs.tmp, dataDirs.data, date, groupsRaw);
+        logger.info('Done analyze router logs', { date, results });
+
+        results = await Promise.all(
+          results
+            .filter((x) => x.result)
+            .map((x) => ({ did: x.did, date, ...toCamelCase(x.result) }))
+            .map((x) => trafficInsight.upsert({ did: x.did, date: x.date }, x))
+        );
+        logger.info('Done insert insight results', { date, results });
+      } catch (err) {
+        logger.error('Failed to analyze router logs', { date, error: err });
+      }
+    };
+
+    const analyzeLock = path.join(logDir, '.analyze.lock');
+    if (fs.existsSync(analyzeLock)) {
+      // FIXME: @wangshijun how do we support real time logs
+      const date = dayjs().subtract(1, 'day').format('YYYY-MM-DD');
+      await doAnalyze(date, cloneDeep(groups));
+    } else {
+      fs.writeFileSync(analyzeLock, '1');
+      for (let i = 1; i <= 30; i++) {
+        const date = dayjs().subtract(i, 'day').format('YYYY-MM-DD');
+        // eslint-disable-next-line no-await-in-loop
+        await doAnalyze(date, cloneDeep(groups));
+      }
+    }
+  };
+
   const updateNodeRouting = async (params, context = {}) => {
     const info = await nodeState.read();
     const { snapshotHash: oldSnapshotHash } = info.routing || {};
@@ -1396,7 +1481,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return attachRuntimeDomainAliases({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
-      node: nodeState,
     });
   };
 
@@ -1405,7 +1489,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return attachRuntimeDomainAliases({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
-      node: nodeState,
     });
   };
 
@@ -1490,7 +1573,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         name: 'rotate-log-files',
         time: '1 0 0 * * *', // rotate at 00:00:01 every day
         fn: rotateRouterLog,
-        options: { runOnInit: false },
+        options: { runOnInit: process.env.ABT_NODE_JOB_NAME === 'rotate-log-files' },
+      },
+      {
+        name: 'analyze-log-files',
+        time: '0 5 0 * * *', // analyze at 00:05:00 every day
+        fn: analyzeRouterLog,
+        options: { runOnInit: process.env.ABT_NODE_JOB_NAME === 'analyze-log-files' },
       },
     ],
 

package/lib/states/blocklet.js

@@ -14,6 +14,7 @@ const {
   getDisplayName,
   forEachBlocklet,
   forEachBlockletSync,
+  forEachComponentV2,
   forEachComponentV2Sync,
   getBlockletServices,
 } = require('@blocklet/meta/lib/util');
@@ -24,6 +25,7 @@ const {
   BLOCKLET_DEFAULT_PORT_NAME,
   BlockletGroup,
 } = require('@blocklet/constant');
+const { refreshPorts } = require('@abtnode/util/lib/port');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet');
@@ -343,6 +345,9 @@ class BlockletState extends BaseState {
     }
   }
 
+  /**
+   * assign ports for blocklet during install/upgrade workflow
+   */
   async getBlockletPorts({
     interfaces = [],
     alreadyAssigned = {},
@@ -351,32 +356,7 @@ class BlockletState extends BaseState {
     defaultPort = 0,
   } = {}) {
     try {
-      const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, meta: 1, children: 1 });
-
-      const occupiedExternalPorts = new Map();
-      const occupiedInternalPorts = new Map();
-
-      const calcPortsFromBlocklet = (blocklet) => {
-        occupiedInternalPorts.set(Number(blocklet.port), true);
-
-        if (blocklet.ports && typeof blocklet.ports === 'object') {
-          Object.keys(blocklet.ports).forEach((key) => {
-            occupiedInternalPorts.set(Number(blocklet.ports[key]), true);
-          });
-        }
-
-        if (Array.isArray(blocklet.meta.interfaces)) {
-          blocklet.meta.interfaces.forEach((x) => {
-            if (x.port && x.port.external) {
-              occupiedExternalPorts.set(Number(x.port.external), true);
-            }
-          });
-        }
-      };
-
-      for (const blocklet of blocklets) {
-        await forEachBlocklet(blocklet, calcPortsFromBlocklet);
-      }
+      const { occupiedExternalPorts, occupiedInternalPorts } = await this._getOccupiedPorts();
 
       const wantedPorts = uniq(
         interfaces
@@ -437,6 +417,30 @@ class BlockletState extends BaseState {
     }
   }
 
+  /**
+   * refresh ports for blocklet if occupied during starting workflow
+   */
+  async refreshBlockletPorts(did, componentDids = []) {
+    const blocklet = await this.getBlocklet(did);
+    if (!blocklet) {
+      throw new Error('Blocklet does not exist');
+    }
+
+    const { occupiedExternalPorts, occupiedInternalPorts } = await this._getOccupiedPorts();
+
+    await forEachComponentV2(blocklet, async (component) => {
+      if (!shouldSkipComponent(component.meta.did, componentDids)) {
+        component.ports = await refreshPorts(component.ports, {
+          blackList: [...occupiedExternalPorts.keys(), ...occupiedInternalPorts.keys()],
+        });
+      }
+    });
+
+    return this.updateBlocklet(did, {
+      children: blocklet.children,
+    });
+  }
+
   async getServices() {
     const blocklets = await this.getBlocklets({}, { meta: 1, children: 1, ports: 1 });
     const services = [];
@@ -515,12 +519,16 @@ class BlockletState extends BaseState {
       const doc = await this.getBlocklet(did);
 
       if (doc.meta?.group === BlockletGroup.gateway && !doc.children?.length) {
-        return this.updateBlocklet(did, { status });
+        const res = await this.updateBlocklet(did, { status });
+        statusLock.release();
+        return res;
       }
 
       // for backward compatibility
       if (!doc.structVersion && !doc.children?.length) {
-        return this.updateBlocklet(did, { status });
+        const res = await this.updateBlocklet(did, { status });
+        statusLock.release();
+        return res;
       }
 
       // update children status
@@ -657,10 +665,43 @@ class BlockletState extends BaseState {
 
   _getStatusLock(did) {
     if (!this.statusLocks.has(did)) {
-      this.statusLocks[did] = new Lock();
+      this.statusLocks.set(did, new Lock());
     }
 
-    return this.statusLocks[did];
+    return this.statusLocks.get(did);
+  }
+
+  async _getOccupiedPorts() {
+    const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, meta: 1, children: 1 });
+
+    const occupiedExternalPorts = new Map();
+    const occupiedInternalPorts = new Map();
+
+    const calcPortsFromBlocklet = (blocklet) => {
+      occupiedInternalPorts.set(Number(blocklet.port), true);
+
+      if (blocklet.ports && typeof blocklet.ports === 'object') {
+        Object.keys(blocklet.ports).forEach((key) => {
+          occupiedInternalPorts.set(Number(blocklet.ports[key]), true);
+        });
+      }
+
+      if (Array.isArray(blocklet.meta.interfaces)) {
+        blocklet.meta.interfaces.forEach((x) => {
+          if (x.port && x.port.external) {
+            occupiedExternalPorts.set(Number(x.port.external), true);
+          }
+        });
+      }
+    };
+
+    for (const blocklet of blocklets) {
+      await forEachBlocklet(blocklet, calcPortsFromBlocklet);
+    }
+    return {
+      occupiedExternalPorts,
+      occupiedInternalPorts,
+    };
   }
 }
 

package/lib/states/index.js

@@ -15,6 +15,8 @@ const CacheState = require('./cache');
 const AuditLogState = require('./audit-log');
 const JobState = require('./job');
 const BackupState = require('./backup');
+const TrafficInsightState = require('./traffic-insight');
+
 const { getDbFilePath } = require('../util');
 
 const models = getServerModels();
@@ -38,6 +40,7 @@ const init = (dataDirs, config = {}) => {
   const auditLogState = new AuditLogState(models.AuditLog, config);
   const jobState = new JobState(models.Job, config);
   const backupState = new BackupState(models.Backup, config);
+  const trafficInsight = new TrafficInsightState(models.TrafficInsight, config);
 
   return {
     node: nodeState,
@@ -53,6 +56,7 @@ const init = (dataDirs, config = {}) => {
     auditLog: auditLogState,
     job: jobState,
     backup: backupState,
+    trafficInsight,
   };
 };
 

package/lib/states/traffic-insight.js

@@ -0,0 +1,25 @@
+const { Op } = require('sequelize');
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').TrafficInsightState>
+ */
+class TrafficInsight extends BaseState {
+  findPaginated({ did = '', startDate = '', endDate = '', paging = { pageSize: 30 } } = {}) {
+    const where = {};
+    if (did) {
+      where.did = did;
+    }
+    if (startDate) {
+      where.date = { [Op.gte]: startDate };
+    }
+    if (endDate) {
+      where.date = where.date || {};
+      where.date[Op.lte] = endDate;
+    }
+
+    return super.paginate({ where }, { date: -1 }, paging);
+  }
+}
+
+module.exports = TrafficInsight;

package/lib/util/blocklet.js

@@ -2,7 +2,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
-const dayjs = require('dayjs');
+const dayjs = require('@abtnode/util/lib/dayjs');
 const shelljs = require('shelljs');
 const os = require('os');
 const tar = require('tar');
@@ -26,7 +26,6 @@ const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet');
 const pm2 = require('@abtnode/util/lib/async-pm2');
 const sleep = require('@abtnode/util/lib/sleep');
 const getPm2ProcessInfo = require('@abtnode/util/lib/get-pm2-process-info');
-const killProcessOccupiedPorts = require('@abtnode/util/lib/kill-process-occupied-ports');
 const { formatEnv } = require('@abtnode/util/lib/security');
 const ensureEndpointHealthy = require('@abtnode/util/lib/ensure-endpoint-healthy');
 const CustomError = require('@abtnode/util/lib/custom-error');
@@ -49,6 +48,7 @@ const {
   getComponentConfig,
 } = require('@blocklet/resolver');
 const formatBackSlash = require('@abtnode/util/lib/format-back-slash');
+const { isPortsOccupiedByOtherProcess, killProcessOccupiedPorts } = require('@abtnode/util/lib/port');
 const { toSvg: createDidLogo } =
   process.env.NODE_ENV !== 'test' ? require('@arcblock/did-motif') : require('@arcblock/did-motif/dist/did-motif.cjs');
 const { createBlockiesSvg } = require('@blocklet/meta/lib/blockies');
@@ -80,6 +80,7 @@ const {
   findWebInterface,
   forEachBlockletSync,
   forEachChildSync,
+  forEachComponentV2,
   forEachComponentV2Sync,
   getSharedConfigObj,
   getComponentName,
@@ -569,7 +570,7 @@ const startBlockletProcess = async (
       };
 
       const clusterMode = get(b.meta, 'capabilities.clusterMode', false);
-      if (clusterMode && blocklet.mode !== BLOCKLET_MODES.DEVELOPMENT) {
+      if (clusterMode && b.mode !== BLOCKLET_MODES.DEVELOPMENT) {
         const clusterSize = Number(blocklet.configObj.BLOCKLET_CLUSTER_SIZE) || +process.env.ABT_NODE_MAX_CLUSTER_SIZE;
         options.execMode = 'cluster';
         options.mergeLogs = true;
@@ -1768,6 +1769,48 @@ const exceedRedemptionPeriod = (expirationDate) => {
   return dayjs().diff(dayjs(expirationDate), 'day') > EXPIRED_BLOCKLET_DATA_RETENTION_DAYS;
 };
 
+const ensureAppPortsNotOccupied = async ({
+  blocklet,
+  componentDids: inputDids,
+  states,
+  manager,
+  checkPortsFn = isPortsOccupiedByOtherProcess,
+}) => {
+  const { did } = blocklet.meta;
+  const componentDids = [];
+  await forEachComponentV2(blocklet, async (b) => {
+    try {
+      if (shouldSkipComponent(b.meta.did, inputDids)) {
+        return;
+      }
+
+      const { processId } = b.env;
+      const { ports } = b;
+      if (
+        await checkPortsFn({
+          ports,
+          pm2ProcessId: processId,
+          printError: logger.error.bind(logger),
+        })
+      ) {
+        componentDids.push(b.meta.did);
+      }
+    } catch (error) {
+      logger.error('Failed to check ports occupied', { error });
+    }
+  });
+
+  let newBlocklet = blocklet;
+  if (componentDids.length) {
+    await states.blocklet.refreshBlockletPorts(did, componentDids);
+    logger.info('refresh component ports', { did, componentDids });
+    await manager._updateBlockletEnvironment(did);
+    newBlocklet = await manager.ensureBlocklet(did);
+  }
+
+  return newBlocklet;
+};
+
 module.exports = {
   updateBlockletFallbackLogo,
   forEachBlocklet,
@@ -1829,4 +1872,5 @@ module.exports = {
   shouldSkipComponent,
   getBlockletURLForLauncher,
   exceedRedemptionPeriod,
+  ensureAppPortsNotOccupied,
 };

package/lib/util/index.js

@@ -4,6 +4,7 @@ const path = require('path');
 const dns = require('dns');
 const crypto = require('crypto');
 const shell = require('shelljs');
+const camelCase = require('lodash/camelCase');
 const get = require('lodash/get');
 const pickBy = require('lodash/pickBy');
 const { isFromPublicKey } = require('@arcblock/did');
@@ -469,6 +470,27 @@ const isServerSite = (domain) =>
 
 const getDbFilePath = (filePath) => (process.env.NODE_ENV === 'test' ? `${filePath}:memory:` : filePath);
 
+const toCamelCase = (obj) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(toCamelCase);
+  }
+
+  const converted = {};
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      converted[camelCase(key)] = toCamelCase(obj[key]);
+    }
+  }
+
+  return converted;
+};
+
 const lib = {
   validateOwner,
   getProviderFromNodeInfo,
@@ -505,6 +527,7 @@ const lib = {
   isBlockletSite,
   isServerSite,
   getDbFilePath,
+  toCamelCase,
 };
 
 module.exports = lib;

package/lib/util/rotator.js

@@ -3,7 +3,7 @@
  */
 const fs = require('fs-extra');
 const path = require('path');
-const moment = require('moment-timezone');
+const dayjs = require('@abtnode/util/lib/dayjs');
 const zlib = require('zlib');
 const log = require('@abtnode/logger');
 
@@ -70,11 +70,11 @@ module.exports = class LogRotate {
    */
   proceed(file, callback = () => {}) {
     // set default final time
-    let finalTime = moment().subtract(1, 'day').format(this.dateFormat);
+    let finalTime = dayjs().subtract(1, 'day').format(this.dateFormat);
     // check for a timezone
     if (this.tz) {
       try {
-        finalTime = moment().tz(this.tz).subtract(1, 'day').format(this.dateFormat);
+        finalTime = dayjs().tz(this.tz).subtract(1, 'day').format(this.dateFormat);
       } catch (err) {
         // use default
       }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.13-beta-0656f92f",
+  "version": "1.16.13-beta-2eb54cbc",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,18 +19,19 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/auth": "1.16.13-beta-0656f92f",
-    "@abtnode/certificate-manager": "1.16.13-beta-0656f92f",
-    "@abtnode/constant": "1.16.13-beta-0656f92f",
-    "@abtnode/cron": "1.16.13-beta-0656f92f",
-    "@abtnode/logger": "1.16.13-beta-0656f92f",
-    "@abtnode/models": "1.16.13-beta-0656f92f",
-    "@abtnode/queue": "1.16.13-beta-0656f92f",
-    "@abtnode/rbac": "1.16.13-beta-0656f92f",
-    "@abtnode/router-provider": "1.16.13-beta-0656f92f",
-    "@abtnode/static-server": "1.16.13-beta-0656f92f",
-    "@abtnode/timemachine": "1.16.13-beta-0656f92f",
-    "@abtnode/util": "1.16.13-beta-0656f92f",
+    "@abtnode/analytics": "1.16.13-beta-2eb54cbc",
+    "@abtnode/auth": "1.16.13-beta-2eb54cbc",
+    "@abtnode/certificate-manager": "1.16.13-beta-2eb54cbc",
+    "@abtnode/constant": "1.16.13-beta-2eb54cbc",
+    "@abtnode/cron": "1.16.13-beta-2eb54cbc",
+    "@abtnode/logger": "1.16.13-beta-2eb54cbc",
+    "@abtnode/models": "1.16.13-beta-2eb54cbc",
+    "@abtnode/queue": "1.16.13-beta-2eb54cbc",
+    "@abtnode/rbac": "1.16.13-beta-2eb54cbc",
+    "@abtnode/router-provider": "1.16.13-beta-2eb54cbc",
+    "@abtnode/static-server": "1.16.13-beta-2eb54cbc",
+    "@abtnode/timemachine": "1.16.13-beta-2eb54cbc",
+    "@abtnode/util": "1.16.13-beta-2eb54cbc",
     "@arcblock/did": "1.18.84",
     "@arcblock/did-auth": "1.18.84",
     "@arcblock/did-ext": "^1.18.84",
@@ -41,10 +42,10 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.18.84",
     "@arcblock/vc": "1.18.84",
-    "@blocklet/constant": "1.16.13-beta-0656f92f",
-    "@blocklet/meta": "1.16.13-beta-0656f92f",
-    "@blocklet/resolver": "1.16.13-beta-0656f92f",
-    "@blocklet/sdk": "1.16.13-beta-0656f92f",
+    "@blocklet/constant": "1.16.13-beta-2eb54cbc",
+    "@blocklet/meta": "1.16.13-beta-2eb54cbc",
+    "@blocklet/resolver": "1.16.13-beta-2eb54cbc",
+    "@blocklet/sdk": "1.16.13-beta-2eb54cbc",
     "@did-space/client": "^0.2.117",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.84",
@@ -56,7 +57,6 @@
     "axon": "^2.0.3",
     "chalk": "^4.1.2",
     "cross-spawn": "^7.0.3",
-    "dayjs": "^1.11.7",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.5.1",
     "escape-string-regexp": "^4.0.0",
@@ -73,7 +73,6 @@
     "kill-port": "^2.0.1",
     "lodash": "^4.17.21",
     "lru-cache": "^6.0.0",
-    "moment-timezone": "^0.5.37",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^3.1.0",
     "p-retry": "4.6.1",
@@ -97,5 +96,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "07996e8ec6fd2141ee3e93dd699ed7fd434bc0ad"
+  "gitHead": "7adf96c2eb31762d8eb14b8121fce9865d6a458c"
 }