@abtnode/core 1.6.6 → 1.6.10

package/lib/blocklet/manager/disk.js

@@ -20,12 +20,13 @@ const hashFiles = require('@abtnode/util/lib/hash-files');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
+const { updateBlocklet: updateDidDocument } = require('@abtnode/util/lib/did-document');
 const { BLOCKLET_PURCHASE_NFT_TYPE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
-const { isFreeBlocklet } = require('@blocklet/meta/lib/util');
+const { isFreeBlocklet, isDeletableBlocklet, getRequiredMissingConfigs } = require('@blocklet/meta/lib/util');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
-const { getRequiredMissingConfigs } = require('@blocklet/meta/lib/util');
+const { getBlockletInfo } = require('@blocklet/meta/lib');
 
 const {
   BlockletStatus,
@@ -243,7 +244,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preStart(b, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did,
             progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
@@ -315,7 +316,7 @@ class BlockletManager extends BaseBlockletManager {
         hooks.preStop({
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           did, // root blocklet did
           notification: states.notification,
           context,
@@ -380,6 +381,9 @@ class BlockletManager extends BaseBlockletManager {
 
     try {
       const blocklet = await this.ensureBlocklet(did);
+      if (isDeletableBlocklet(blocklet) === false) {
+        throw new Error('Blocklet is protected from accidental deletion');
+      }
 
       const nodeEnvironments = await states.node.getEnvironments();
 
@@ -388,7 +392,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preUninstall({
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did
             notification: states.notification,
             context,
@@ -513,7 +517,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // run hook
     const nodeEnvironments = await states.node.getEnvironments();
-    newConfigs.forEach((x) => {
+    for (const x of newConfigs) {
       if (x.key === 'BLOCKLET_APP_SK') {
         try {
           fromSecretKey(x.value);
@@ -524,6 +528,13 @@ class BlockletManager extends BaseBlockletManager {
             throw new Error('Invalid custom blocklet secret key');
           }
         }
+
+        // Ensure sk is not used by other blocklets, otherwise we may encounter appDid collision
+        const blocklets = await states.blocklet.getBlocklets({});
+        const others = blocklets.filter((b) => b.meta.did !== did);
+        if (others.some((b) => b.environments.find((e) => e.key === 'BLOCKLET_APP_SK').value === x.value)) {
+          throw new Error('Invalid custom blocklet secret key: already used by another blocklet');
+        }
       }
 
       if (x.key === 'BLOCKLET_WALLET_TYPE') {
@@ -532,8 +543,16 @@ class BlockletManager extends BaseBlockletManager {
         }
       }
 
+      if (x.key === 'BLOCKLET_DELETABLE') {
+        if (['yes', 'no'].includes(x.value) === false) {
+          throw new Error('BLOCKLET_DELETABLE must be either "yes" or "no"');
+        }
+      }
+
       blocklet.configObj[x.key] = x.value;
-    });
+    }
+
+    // FIXME: we should also call preConfig for child blocklets
     await hooks.preConfig({
       appDir: blocklet.env.appDir,
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
@@ -897,7 +916,7 @@ class BlockletManager extends BaseBlockletManager {
       };
 
       const childConfigs = await states.blockletExtras.getChildConfigs(did, childDid);
-      fillBlockletConfigs(child, childConfigs);
+      fillBlockletConfigs(child, childConfigs, blocklet);
     }
 
     return blocklet;
@@ -1496,6 +1515,15 @@ class BlockletManager extends BaseBlockletManager {
       return null;
     }
 
+    // When new version found from the store where the blocklet was installed from, we should use that store first
+    if (blocklet.source === BlockletSource.registry && blocklet.deployedFrom) {
+      const latestFromSameRegistry = versions.find((x) => x.registryUrl === blocklet.deployedFrom);
+      if (latestFromSameRegistry) {
+        return latestFromSameRegistry;
+      }
+    }
+
+    // Otherwise try upgrading from other store
     let latestBlockletVersion = versions[0];
     versions.forEach((item) => {
       if (semver.lt(latestBlockletVersion.version, item.version)) {
@@ -1561,7 +1589,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await this._setConfigs(did);
 
-      logger.info('blocklet added to database', { meta });
+      logger.info('blocklet added to database', { did: meta.did });
 
       const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
       this.emit(BlockletEvents.added, blocklet1);
@@ -1855,7 +1883,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: blocklet.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -1865,7 +1893,19 @@ class BlockletManager extends BaseBlockletManager {
 
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
-      logger.info('blocklet installed', { source, meta });
+      logger.info('blocklet installed', { source, did: meta.did });
+      if (process.env.NODE_ENV !== 'test') {
+        const nodeInfo = await states.node.read();
+        const blockletInfo = getBlockletInfo(blocklet, nodeInfo.sk);
+        const updateDidDnsResult = await updateDidDocument({
+          wallet: blockletInfo.wallet,
+          domain: nodeInfo.didDomain,
+          nodeDid: nodeInfo.did,
+          didRegistryUrl: nodeInfo.didRegistry,
+        });
+        logger.info('updated did document', { updateDidDnsResult, blockletId: blocklet.meta.did });
+      }
+
       this.emit(BlockletEvents.installed, { blocklet, context });
 
       states.notification.create({
@@ -1943,7 +1983,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -1959,7 +1999,7 @@ class BlockletManager extends BaseBlockletManager {
             blocklet: b,
             oldVersion,
             newVersion: version,
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             appDir: b.env.appDir,
             did: b.meta.did,
             notification: states.notification,
@@ -2251,8 +2291,9 @@ class BlockletManager extends BaseBlockletManager {
     try {
       const state = await states.blocklet.getBlocklet(did);
       if (state && util.shouldUpdateBlockletStatus(state.status)) {
-        const result = await states.blocklet.setBlockletStatus(did, pm2StatusMap[pm2Status]);
-        logger.info('sync pm2 status to blocklet', { result });
+        const newStatus = pm2StatusMap[pm2Status];
+        await states.blocklet.setBlockletStatus(did, newStatus);
+        logger.info('sync pm2 status to blocklet', { did, pm2Status, newStatus });
       }
     } catch (error) {
       logger.error('sync pm2 status to blocklet failed', { did, pm2Status, error });

package/lib/cert.js

@@ -0,0 +1,124 @@
+const { EventEmitter } = require('events');
+const CertificateManager = require('@abtnode/certificate-manager/sdk/manager');
+const logger = require('@abtnode/logger')('@abtnode/core:cert');
+const states = require('./states');
+
+const onCertExpired = async (cert) => {
+  logger.info('send certificate expire notification', { domain: cert.domain });
+  states.notification.create({
+    title: 'SSL Certificate Expired',
+    description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in Blocklet Server`,
+    severity: 'error',
+    entityType: 'certificate',
+    entityId: cert.id,
+  });
+};
+
+const onCertAboutExpire = (cert) => {
+  logger.info('send certificate about-expire notification', { domain: cert.domain });
+  states.notification.create({
+    title: 'SSL Certificate Expire Warning',
+    description: `Your SSL certificate for domain ${cert.domain} will expire in ${
+      cert.expireInDays
+    } days (on ${new Date(cert.validTo).toLocaleString()}), please remember to update it in Blocklet Server`,
+    severity: 'warning',
+    entityType: 'certificate',
+    entityId: cert.id, // eslint-disable-line no-underscore-dangle
+  });
+};
+
+const onCertIssued = (cert) => {
+  states.notification.create({
+    title: 'Certificate Issued',
+    description: `The ${cert.domain} certificate is issued successfully`,
+    severity: 'success',
+    entityType: 'certificate',
+    entityId: cert.id,
+  });
+};
+
+class Cert extends EventEmitter {
+  constructor({ maintainerEmail, dataDir }) {
+    super();
+
+    this.manager = new CertificateManager({ maintainerEmail, dataDir });
+
+    this.manager.on('cert.issued', (cert) => {
+      this.emit('cert.issued', cert);
+      onCertIssued(cert);
+    });
+
+    this.manager.on('cert.expired', onCertExpired);
+    this.manager.on('cert.about_to_expire', onCertAboutExpire);
+  }
+
+  start() {
+    return this.manager.start();
+  }
+
+  static fixCertificate(entity) {
+    // Hack: this logic exists because gql does not allow line breaks in arg values
+    entity.privateKey = entity.privateKey.split('|').join('\n');
+    entity.certificate = entity.certificate.split('|').join('\n');
+  }
+
+  getAll() {
+    return this.manager.getAll();
+  }
+
+  getAllNormal() {
+    return this.manager.getAllNormal();
+  }
+
+  getNormalByDomain(domain) {
+    return this.manager.getNormalByDomain(domain);
+  }
+
+  getByDomain(domain) {
+    return this.manager.getByDomain(domain);
+  }
+
+  async add(data) {
+    if (!data.certificate || !data.privateKey) {
+      throw new Error('certificate and privateKey is required');
+    }
+
+    Cert.fixCertificate(data);
+
+    await this.manager.add(data);
+    logger.info('add certificate result', { name: data.name });
+    this.emit('cert.added', data);
+  }
+
+  async issue({ domain }) {
+    logger.info(`generate certificate for ${domain}`);
+
+    return this.manager.issue(domain);
+  }
+
+  async upsertByDomain(data) {
+    return this.manager.upsertByDomain(data);
+  }
+
+  async update(data) {
+    return this.manager.update(data.id, { name: data.name, public: data.public });
+  }
+
+  async remove({ id }) {
+    await this.manager.remove(id);
+    logger.info('delete certificate', { id });
+    this.emit('cert.removed');
+
+    return {};
+  }
+
+  async addWithoutValidations(data) {
+    return this.manager.addWithoutValidations(data);
+  }
+
+  async updateWithoutValidations(id, data) {
+    return this.manager.updateWithoutValidations(id, data);
+  }
+}
+
+module.exports = Cert;

package/lib/event.js

@@ -1,5 +1,8 @@
+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');
 
@@ -43,9 +46,13 @@ module.exports = ({
   let eventHandler = null;
 
   const onEvent = (name, data) => {
-    events.emit(name, data);
+    let safeData = data;
+    if (get(data, 'meta.did', '')) {
+      safeData = wipeSensitiveData(cloneDeep(data));
+    }
+    events.emit(name, safeData);
     if (typeof eventHandler === 'function') {
-      eventHandler({ name, data });
+      eventHandler({ name, data: safeData });
     }
   };
 

package/lib/index.js

@@ -11,6 +11,7 @@ const {
   toBlockletSource,
 } = require('@blocklet/meta/lib/constants');
 const { listProviders } = require('@abtnode/router-provider');
+const { DEFAULT_CERTIFICATE_EMAIL } = require('@abtnode/constant');
 
 const RoutingSnapshot = require('./states/routing-snapshot');
 const BlockletRegistry = require('./blocklet/registry');
@@ -22,6 +23,7 @@ const NodeAPI = require('./api/node');
 const TeamAPI = require('./api/team');
 const WebHook = require('./webhook');
 const states = require('./states');
+const Cert = require('./cert');
 
 const IP = require('./util/ip');
 const DomainStatus = require('./util/domain-status');
@@ -108,7 +110,11 @@ function ABTNode(options) {
   // Initialize storage
   states.init(dataDirs, options);
 
-  const routerManager = new RouterManager();
+  const certManager = new Cert({
+    maintainerEmail: DEFAULT_CERTIFICATE_EMAIL,
+    dataDir: dataDirs.certManagerModule,
+  });
+  const routerManager = new RouterManager({ certManager });
   const routingSnapshot = new RoutingSnapshot({
     baseDir: dataDirs.core,
     getRoutingData: async () => {
@@ -117,7 +123,6 @@ function ABTNode(options) {
       return { sites };
     },
   });
-
   const blockletRegistry = new BlockletRegistry();
   const blockletManager = new BlockletManager({
     dataDirs,
@@ -141,10 +146,10 @@ function ABTNode(options) {
     getCertificates,
     getSitesFromSnapshot,
     getRoutingCrons,
-  } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager });
+    ensureDashboardCertificate,
+  } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager });
 
   const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
-
   const nodeAPI = new NodeAPI(states.node, blockletRegistry);
   const teamAPI = new TeamAPI({ states, teamManager });
 
@@ -162,10 +167,10 @@ function ABTNode(options) {
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
     takeRoutingSnapshot,
-    routerManager,
     handleRouting,
     domainStatus,
     teamAPI,
+    certManager,
   });
 
   const isInitialized = async () => {
@@ -311,6 +316,7 @@ function ABTNode(options) {
     takeRoutingSnapshot,
     getSitesFromSnapshot,
     ensureDashboardRouting,
+    ensureDashboardCertificate,
 
     addDomainAlias: routerManager.addDomainAlias.bind(routerManager),
     deleteDomainAlias: routerManager.deleteDomainAlias.bind(routerManager),
@@ -319,11 +325,13 @@ function ABTNode(options) {
     checkDomains: domainStatus.checkDomainsStatus.bind(domainStatus),
     handleRouting,
 
-    updateNginxHttpsCert: routerManager.updateNginxHttpsCert.bind(routerManager),
+    certManager,
+    updateNginxHttpsCert: certManager.update.bind(certManager), // TODO: 重命名：updateCert
     getCertificates,
-    addCertificate: routerManager.addCertificate.bind(routerManager),
-    deleteCertificate: routerManager.deleteCertificate.bind(routerManager),
-    findCertificateByDomain: routerManager.findCertificateByDomain.bind(routerManager),
+    addCertificate: certManager.add.bind(certManager),
+    deleteCertificate: certManager.remove.bind(certManager),
+    findCertificateByDomain: certManager.getByDomain.bind(certManager),
+    issueLetsEncryptCert: certManager.issue.bind(certManager),
 
     // Access Key
     getAccessKeys: states.accessKey.list.bind(states.accessKey),
@@ -385,11 +393,23 @@ function ABTNode(options) {
   };
 
   if (options.daemon) {
+    certManager.start(); // 启动证书服务
+
     if (process.env.NODE_ENV === 'development') {
       initCron();
     } else {
       // We should only respond to pm2 events when node is alive
-      events.on('node.started', () => {
+      events.on('node.started', async () => {
+        const info = await states.node.read();
+        certManager
+          .issue({ domain: `${info.did.toLowerCase()}.${info.didDomain}` })
+          .then(() => {
+            logger.info('add issue daemon certificate job');
+          })
+          .catch((error) => {
+            logger.error('issue daemon certificate job failed', { error });
+          });
+
         pm2Events.resume();
         initCron();
       });

package/lib/migrations/1.6.7-certificate.js

@@ -0,0 +1,30 @@
+module.exports = async ({ states, node, printInfo }) => {
+  printInfo('Migrate certificates...');
+  const certs = await states.certificate.find(
+    {},
+    {
+      domain: 1,
+      privateKey: 1,
+      certificate: 1,
+      createdAt: 1,
+      updatedAt: 1,
+    }
+  );
+
+  const tasks = certs.map((cert) => {
+    const data = {
+      _id: cert.id,
+      domain: cert.domain,
+      privateKey: cert.privateKey,
+      certificate: cert.certificate,
+      createdAt: cert.createdAt,
+      updatedAt: cert.updatedAt,
+      source: 'lets_encrypt',
+      status: 'generated',
+    };
+
+    return node.certManager.addWithoutValidations(data);
+  });
+
+  await Promise.all(tasks);
+};

package/lib/migrations/1.6.9-update-node-info-and-certificate.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-await-in-loop */
+
+const { DEFAULT_DID_REGISTRY, DEFAULT_DID_DOMAIN } = require('@abtnode/constant');
+const { isEmpty, omit } = require('lodash');
+
+const updateNodeInfo = async ({ printInfo, states }) => {
+  // add didRegistry and didDomain
+  const info = await states.node.read();
+  const data = {};
+  if (!info.didRegistry) {
+    data.didRegistry = DEFAULT_DID_REGISTRY;
+  }
+
+  if (!info.didDomain) {
+    data.didDomain = DEFAULT_DID_DOMAIN;
+  }
+
+  if (!isEmpty(data)) {
+    await states.node.update({ _id: info._id }, { $set: data });
+  }
+
+  printInfo('update did registry and did domain successfully');
+};
+
+const updateCertificate = async ({ node, printInfo }) => {
+  const certs = await node.certManager.getAllNormal();
+  for (const cert of certs || []) {
+    await node.certManager.updateWithoutValidations(cert.id, omit(cert, 'id'));
+  }
+
+  printInfo('update certificate successfully');
+};
+
+/* eslint-disable no-underscore-dangle */
+module.exports = async ({ node, printInfo, states }) => {
+  await updateNodeInfo({ printInfo, states });
+  await updateCertificate({ node, printInfo, states });
+};