@abtnode/core 1.15.17 → 1.16.0-beta-b16cb035

package/lib/util/chain.js

@@ -1,4 +1,4 @@
-const axios = require('axios');
+const axios = require('@abtnode/util/lib/axios');
 const get = require('lodash/get');
 
 const getFactoryState = async (endpoint, address) => {

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

@@ -1,16 +1,9 @@
-const {
-  NODE_REGISTER_URL,
-  BLOCKLET_STORE_URL,
-  BLOCKLET_STORE_URL_DEV,
-  WEB_WALLET_URL,
-  NODE_PACKAGE_NAME,
-  NODE_COMMAND_NAME,
-} = require('@abtnode/constant');
+const { NODE_REGISTER_URL, BLOCKLET_STORE, BLOCKLET_STORE_DEV } = require('@abtnode/constant');
 const canPackageReadWrite = require('@abtnode/util/lib/can-pkg-rw');
 
 const getDefaultAutoUpgrade = () => {
   try {
-    return canPackageReadWrite(NODE_COMMAND_NAME, NODE_PACKAGE_NAME);
+    return canPackageReadWrite(process.env.ABT_NODE_BINARY_NAME, process.env.ABT_NODE_PACKAGE_NAME);
   } catch (err) {
     return false;
   }
@@ -23,27 +16,16 @@ const defaultNodeConfigs = {
   blockletRegistryList: {
     getDefaultValue: () => [
       {
-        name: 'Official Store',
-        description: 'ArcBlock official blocklet registry',
-        url: BLOCKLET_STORE_URL,
-        logoUrl: '/logo.png',
-        maintainer: 'arcblock',
-        selected: true,
+        ...BLOCKLET_STORE,
         protected: true,
       },
       {
-        name: 'Dev Store',
-        description: 'ArcBlock dev registry that contains demo and example blocklets',
-        url: BLOCKLET_STORE_URL_DEV,
-        maintainer: 'arcblock',
-        logoUrl: '/logo.png',
-        selected: false,
+        ...BLOCKLET_STORE_DEV,
         protected: false,
       },
     ],
   },
-  registerUrl: { getDefaultValue: () => NODE_REGISTER_URL }, // removed in 1.5.1
-  webWalletUrl: { getDefaultValue: () => WEB_WALLET_URL },
+  registerUrl: { getDefaultValue: () => NODE_REGISTER_URL },
 };
 
 const lib = {

package/lib/util/disk-monitor.js

@@ -1,22 +1,26 @@
-const systeminformation = require('@abtnode/util/lib/sys-info');
 const logger = require('@abtnode/logger')('@abtnode/disk-monitor');
+const info = require('./sysinfo');
 
 const states = require('../states');
 
 /**
- *
- * @param {number} threshold Threshold for disk alarms, percentage
+ * @param {number} threshold Threshold for disk alerts, percentage
  */
 const check = async (threshold) => {
-  const info = await systeminformation.get();
-  const usageRatio = (info.disk.used / info.disk.total) * 100;
-  const usageRationText = `${usageRatio.toFixed(2)}%`;
-  logger.info('monitoring disk usage', { usage: usageRationText, threshold });
+  const { disks } = await info.getSysInfo();
+  for (const disk of disks) {
+    const usageRatio = (disk.used / disk.total) * 100;
+    const usageRatioPercent = `${usageRatio.toFixed(2)}%`;
+    logger.info('check disk usage', { usage: usageRatioPercent, threshold });
 
-  if (usageRatio >= threshold) {
+    if (usageRatio < threshold) {
+      return;
+    }
+
+    // eslint-disable-next-line no-await-in-loop
     await states.notification.create({
       title: 'Disk Usage Alert',
-      description: `More than ${usageRationText} disk space has been used`,
+      description: `More than ${usageRatioPercent} space has been used for disk ${disk.device}, the blocklet server may not function properly.`,
       entityType: 'node',
       severity: 'warning',
       sticky: true,
@@ -30,7 +34,6 @@ const getCron = () => ({
   fn: async () => {
     const nodeInfo = await states.node.read();
     const threshold = nodeInfo.diskAlertThreshold;
-
     await check(threshold);
   },
   options: { runOnInit: true },

package/lib/util/domain-status.js

@@ -1,44 +1,113 @@
+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;
   }
 
-  checkDomainsStatus({ domains } = {}) {
+  async getHttpsCert(domain) {
+    const matchedCert = await this.routerManager.getMatchedCert(domain);
+
+    if (matchedCert) {
+      return matchedCert;
+    }
+
+    return new Promise((resolve) => {
+      const req = https.request(
+        {
+          host: domain,
+          path: WELLKNOWN_PING_PREFIX,
+          method: 'GET',
+          timeout: 1000 * 10,
+        },
+        (res) => {
+          try {
+            const data = res.socket.getPeerCertificate();
+            const cert = {
+              issuer: {
+                countryName: data.issuer.C,
+                organizationName: data.issuer.O,
+                commonName: data.issuer.CN,
+              },
+              validFrom: data.valid_from,
+              validTo: data.valid_to,
+            };
+            resolve(cert);
+          } catch {
+            resolve(null);
+          }
+        }
+      );
+
+      req.on('error', () => {
+        resolve(null);
+      });
+
+      req.end();
+    });
+  }
+
+  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.routerManager.getMatchedCert(domain), checkDomainDnsWrapper(domain)])
-        .then((data) => {
-          const [matchedCert, dns] = data;
-          this.emit('domain.status', { domain, matchedCert, isHttps: !!matchedCert, dns });
+      Promise.all([this.getHttpsCert(domain), checkDomainDnsWrapper(domain)])
+        .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/get-accessible-external-node-ip.js

@@ -1,9 +1,9 @@
 const joinUrl = require('url-join');
 const axios = require('@abtnode/util/lib/axios');
-const { DEFAULT_DASHBOARD_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
+const { DEFAULT_IP_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
 const { get: getIp } = require('./ip');
 
-const getNodeDomain = (ip) => (ip ? DEFAULT_DASHBOARD_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
+const getNodeDomain = (ip) => (ip ? DEFAULT_IP_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
 
 let cache = null;
 

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

@@ -0,0 +1,13 @@
+const { DEFAULT_IP_DOMAIN_SUFFIX, SLOT_FOR_IP_DNS_SITE } = require('@abtnode/constant');
+const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
+const formatName = require('@abtnode/util/lib/format-name');
+
+const getIpDnsDomainForBlocklet = (blocklet) => {
+  return `${encodeBase32(blocklet.meta.did)}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DOMAIN_SUFFIX}`;
+};
+
+const getDidDomainForBlocklet = ({ appPid, didDomain }) => {
+  return `${encodeBase32(appPid)}.${didDomain}`;
+};
+
+module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet, formatName };

package/lib/util/get-meta-from-url.js

@@ -0,0 +1,33 @@
+const { isFreeBlocklet } = require('@blocklet/meta/lib/util');
+
+const logger = require('@abtnode/logger')('getMetaFromUrl');
+
+const { getBlockletMetaFromUrl } = require('./blocklet');
+const { getStoreMeta, parseSourceUrl } = require('./store');
+const { getFactoryState } = require('./chain');
+
+const getMetaFromUrl = async ({ url, checkPrice = false }) => {
+  const meta = await getBlockletMetaFromUrl(url);
+  let isFree = isFreeBlocklet(meta);
+
+  if (checkPrice && !isFree && meta.nftFactory) {
+    try {
+      const registryMeta = await getStoreMeta(new URL(url).origin);
+
+      if (registryMeta.chainHost) {
+        const state = await getFactoryState(registryMeta.chainHost, meta.nftFactory);
+        if (state) {
+          isFree = false;
+        }
+      }
+    } catch (error) {
+      logger.warn('failed when checking if the blocklet is free', { did: meta.did, error });
+    }
+  }
+
+  const { inStore, registryUrl } = await parseSourceUrl(url);
+
+  return { meta, isFree, inStore, registryUrl };
+};
+
+module.exports = getMetaFromUrl;