@abtnode/core 1.16.20-beta-cf6dfce1 → 1.16.20-beta-148929e2

package/lib/blocklet/manager/disk.js

@@ -2483,31 +2483,38 @@ class DiskBlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _updateBlockletEnvironment(did) {
+  async getBlockletEnvironments(did) {
     const blockletWithEnv = await this.getBlocklet(did);
-    const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
-
     const appSystemEnvironments = {
       ...getAppSystemEnvironments(blockletWithEnv, nodeInfo, this.dataDirs),
       ...getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo),
     };
 
     // fill environments to blocklet and components
-    blocklet.environments = formatEnvironments({
-      ...getComponentSystemEnvironments(blockletWithEnv),
-      ...appSystemEnvironments,
-    });
+    return {
+      all: formatEnvironments({
+        ...getComponentSystemEnvironments(blockletWithEnv),
+        ...appSystemEnvironments,
+      }),
+      appSystemEnvironments,
+    };
+  }
+
+  async _updateBlockletEnvironment(did) {
+    const blockletWithEnv = await this.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
+
+    const { all, appSystemEnvironments } = await this.getBlockletEnvironments(did);
+    blocklet.environments = all;
 
     const envMap = {};
     forEachBlockletSync(blockletWithEnv, (child, { ancestors }) => {
       const id = getComponentId(child, ancestors);
       envMap[id] = child;
     });
-
     forEachChildSync(blocklet, (child, { ancestors }) => {
       const id = getComponentId(child, ancestors);
-
       const childWithEnv = envMap[id];
       if (childWithEnv) {
         child.environments = formatEnvironments({
@@ -2516,10 +2523,8 @@ class DiskBlockletManager extends BaseBlockletManager {
         });
       }
     });
-
     // put BLOCKLET_APP_ID at root level for indexing
     blocklet.appDid = appSystemEnvironments.BLOCKLET_APP_ID;
-
     if (!Array.isArray(blocklet.migratedFrom)) {
       blocklet.migratedFrom = [];
     }
@@ -2527,7 +2532,6 @@ class DiskBlockletManager extends BaseBlockletManager {
     if (!blocklet.appPid) {
       blocklet.appPid = appSystemEnvironments.BLOCKLET_APP_PID;
     }
-
     // update state to db
     await states.blockletExtras.updateByDid(did, { appDid: blocklet.appDid });
     return states.blocklet.updateBlocklet(did, blocklet);

package/lib/cert.js

@@ -4,50 +4,6 @@ const logger = require('@abtnode/logger')('@abtnode/core:cert');
 const { EVENTS } = require('@abtnode/constant');
 const { BlockletEvents } = require('@blocklet/constant');
 
-const onCertExpired = (cert, states) => {
-  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, states) => {
-  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) => {
-  states.notification.create({
-    title: 'Certificate Issued',
-    description: `The ${cert.domain} certificate is issued successfully`,
-    severity: 'success',
-    entityType: 'certificate',
-    entityId: cert.id,
-  });
-};
-
-const onCertIssueFailed = (cert, states) => {
-  states.notification.create({
-    title: 'Certificate Issue Failed',
-    description: `Failed to issue certificate for ${cert.domain}`,
-    severity: 'error',
-    entityType: 'certificate',
-    entityId: cert.id,
-  });
-};
-
 const getDomainFromInput = (input) => {
   if (Object.prototype.toString.call(input) === '[object Object]') {
     return input.domain;
@@ -62,15 +18,15 @@ class Cert extends EventEmitter {
 
     this.manager = new CertificateManager({ maintainerEmail, dataDir });
 
-    this.manager.on('cert.issued', this._onCertIssued.bind(this));
-    this.manager.on('cert.expired', this._onCertExpired.bind(this));
-    this.manager.on('cert.about_to_expire', this._onCertAboutToExpire.bind(this));
-    this.manager.on('cert.error', this._onCertError.bind(this));
+    this.manager.on('cert.issued', this.onCertIssued.bind(this));
+    this.manager.on('cert.expired', this.onCertExpired.bind(this));
+    this.manager.on('cert.about_to_expire', this.onCertAboutToExpire.bind(this));
+    this.manager.on('cert.error', this.onCertError.bind(this));
 
     /**
      * Array<{domain: string, did: string}>
      */
-    this._blockletDomains = [];
+    this.blockletDomains = [];
     this.states = states;
   }
 
@@ -116,18 +72,37 @@ class Cert extends EventEmitter {
   }
 
   /**
-   * @param {{
-   *   did?:string // blocklet.meta.did
-   * }}
+   * 签发证书
+   * @param object data
+   * @param string data.domain Domain name
+   * @param string data.did Blocklet DID
+   * @param object options
+   * @param number options.delay Delay time in ms
    */
-  issue({ domain, did }) {
+  issue({ domain, did, siteId, inBlockletSetup = false }, { delay = 0 } = {}) {
     logger.info(`generate certificate for ${domain}`);
 
     if (did) {
-      this._bindBlocklet({ domain, did });
+      this.bindBlocklet({ domain, did });
     }
 
-    return this.manager.issue(domain);
+    return this.manager
+      .issue({ domain, siteId, inBlockletSetup }, { delay, metadata: { inBlockletSetup, blockletDid: did } })
+      .then(async (cert) => {
+        const site = await this.states.site.findOne({ id: siteId });
+        for (const d of site.domainAliases) {
+          if (d.value === domain) {
+            d.certificateId = cert.id;
+
+            break;
+          }
+        }
+
+        await this.states.site.update({ id: siteId }, { $set: { domainAliases: site.domainAliases } });
+        logger.info('updated cert id for domain alias', { domain, did, certId: cert.id });
+
+        return cert;
+      });
   }
 
   async upsertByDomain(data) {
@@ -157,11 +132,11 @@ class Cert extends EventEmitter {
     return this.manager.updateWithoutValidations(id, data);
   }
 
-  _bindBlocklet({ domain, did }) {
+  bindBlocklet({ domain, did }) {
     // only save 100 domains in memory
-    const list = this._blockletDomains.slice(-100).filter((x) => x.domain !== domain);
+    const list = this.blockletDomains.slice(-100).filter((x) => x.domain !== domain);
     list.push({ domain, did });
-    this._blockletDomains = list;
+    this.blockletDomains = list;
   }
 
   /**
@@ -173,8 +148,8 @@ class Cert extends EventEmitter {
    *   domain: string
    * }} cert
    */
-  _emitEvent(event, cert) {
-    const blockletDomain = this._blockletDomains.find((x) => x.domain === cert.domain);
+  emitEvent(event, cert) {
+    const blockletDomain = this.blockletDomains.find((x) => x.domain === cert.domain);
     if (blockletDomain) {
       this.emit(event.blocklet, { ...cert, meta: { did: blockletDomain.did } });
     } else {
@@ -182,24 +157,58 @@ class Cert extends EventEmitter {
     }
   }
 
-  _onCertIssued(cert) {
-    this._emitEvent({ blocklet: BlockletEvents.certIssued, server: EVENTS.CERT_ISSUED }, cert);
+  onCertIssued(cert) {
+    this.emitEvent({ blocklet: BlockletEvents.certIssued, server: EVENTS.CERT_ISSUED }, cert);
 
-    onCertIssued(cert, this.states);
+    this.states.notification.create({
+      title: 'Certificate Issued',
+      description: `The ${cert.domain} certificate is issued successfully`,
+      severity: 'success',
+      entityType: 'certificate',
+      entityId: cert.id,
+    });
+
+    logger.info('send certificate issued notification', { domain: cert.domain, certId: cert.id });
   }
 
-  _onCertError(cert) {
-    this._emitEvent({ blocklet: BlockletEvents.certError, server: EVENTS.CERT_ERROR }, cert);
+  onCertError(cert) {
+    this.emitEvent({ blocklet: BlockletEvents.certError, server: EVENTS.CERT_ERROR }, cert);
+
+    this.states.notification.create({
+      title: 'Certificate Issue Failed',
+      description: `Failed to issue certificate for ${cert.domain}`,
+      severity: 'error',
+      entityType: 'certificate',
+      entityId: cert.id,
+    });
 
-    onCertIssueFailed(cert, this.states);
+    logger.info('send certificate issue failed notification', { domain: cert.domain, certId: cert.id });
   }
 
-  _onCertExpired(cert) {
-    onCertExpired(cert, this.states);
+  onCertExpired(cert) {
+    this.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,
+    });
+
+    logger.info('send certificate expire notification', { domain: cert.domain, certId: cert.id });
   }
 
-  _onCertAboutToExpire(cert) {
-    onCertAboutExpire(cert, this.states);
+  onCertAboutToExpire(cert) {
+    this.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
+    });
+
+    logger.info('send certificate about-expire notification', { domain: cert.domain, certId: cert.id });
   }
 }
 

package/lib/event/index.js

@@ -9,6 +9,7 @@ const {
   BlockletSource,
   BlockletEvents,
   BlockletInternalEvents,
+  BLOCKLET_CONFIGURABLE_KEY,
 } = require('@blocklet/constant');
 const { EVENTS, BACKUPS } = require('@abtnode/constant');
 const { NodeMonitSender } = require('../monitor/node-monit-sender');
@@ -380,6 +381,19 @@ module.exports = ({
     }
   };
 
+  const updateBlockletAPPURL = async (event, data) => {
+    if (data?.metadata?.inBlockletSetup === true && data?.metadata?.blockletDid) {
+      await blockletManager.config({
+        did: data?.metadata?.blockletDid,
+        configs: [{ key: BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_URL, value: `https://${data.domain}` }],
+        skipDidDocument: true,
+        skipHook: true,
+      });
+
+      logger.info(`update blocklet app url on ${event}`, { domain: data.domain, did: data?.metadata?.blockletDid });
+    }
+  };
+
   /**
    *
    *
@@ -487,6 +501,7 @@ module.exports = ({
 
   listen(certManager, EVENTS.CERT_ISSUED, onEvent);
   listen(certManager, EVENTS.CERT_ERROR, onEvent);
+  listen(certManager, BlockletEvents.certIssued, updateBlockletAPPURL);
   listen(certManager, BlockletEvents.certIssued, onEvent);
   listen(certManager, BlockletEvents.certError, onEvent);
 

package/lib/index.js

@@ -309,6 +309,7 @@ function ABTNode(options) {
     getBlocklet: blockletManager.detail.bind(blockletManager),
     getBlockletDiff: blockletManager.diff.bind(blockletManager),
     hasBlocklet: blockletManager.hasBlocklet.bind(blockletManager),
+    getBlockletEnvironments: blockletManager.getBlockletEnvironments.bind(blockletManager),
     updateAllBlockletEnvironment: blockletManager.updateAllBlockletEnvironment.bind(blockletManager),
     setBlockletInitialized: blockletManager.setInitialized.bind(blockletManager),
     setBlockletOwner: blockletManager.updateOwner.bind(blockletManager),

package/lib/router/manager.js

@@ -186,7 +186,10 @@ class RouterManager extends EventEmitter {
     return dbSite;
   }
 
-  async addDomainAlias({ id, domainAlias: tmpAlias, force, type, nftDid, chainHost }, context = {}) {
+  async addDomainAlias(
+    { id, domainAlias: tmpAlias, force, type, nftDid, chainHost, inBlockletSetup = false },
+    context = {}
+  ) {
     const domainAlias = await validateAddDomainAlias(tmpAlias, context);
     const dbSite = await states.site.findOne({ id });
     if (!dbSite) {
@@ -224,19 +227,28 @@ class RouterManager extends EventEmitter {
       item.chainHost = chainHost;
     }
 
-    const updateResult = await states.site.update({ id }, { $set: { domainAliases: [...doc.domainAliases, item] } });
-    logger.debug('add domain alias update result', { id, updateResult, domainAlias });
+    await states.site.update({ id }, { $set: { domainAliases: [...doc.domainAliases, item] } });
+    logger.info('added domain alias', { id, domainAlias });
 
+    const did = getDidFromDomainGroupName(doc.domain); // TODO: 是不是可靠？
     if (type === 'nft-domain') {
-      const did = getDidFromDomainGroupName(doc.domain); // TODO: 是不是可靠？
       const didDomain = doc.domainAliases.find((x) => isDidDomain(x.value));
       const blocklet = await states.blocklet.getBlocklet(did);
       const nodeInfo = await states.node.read();
 
       await updateNFTDomainRecord({ name: domainAlias, value: didDomain.value, blocklet, nodeInfo });
-      logger.info('update nft domain record', { domain: domainAlias, didDomain: '', nftDid, id });
+      logger.info('update nft domain record', { domain: domainAlias, didDomain, nftDid, id });
     }
 
+    this.certManager
+      .issue({ domain: domainAlias, did, siteId: id, inBlockletSetup }, { delay: 5000 })
+      .then(() => {
+        logger.info('issue cert for domain alias', { domain: domainAlias, did });
+      })
+      .catch((error) => {
+        logger.error('issue cert for domain alias failed', { error, domain: domainAlias, did });
+      }); // 延迟 5s, 需要等待的原因: Nginx Reload, DNS 生效
+
     const newSite = await states.site.findOne({ id });
     await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 

package/lib/util/blocklet.js

@@ -426,7 +426,6 @@ const getRuntimeEnvironments = (blocklet, nodeEnvironments, ancestors) => {
     ...getSharedConfigObj((ancestors || [])[0], blocklet),
     ...blocklet.environmentObj,
     ...devEnvironments,
-    BLOCKLET_WEB_PORTS: JSON.stringify(ports),
     BLOCKLET_MOUNT_POINTS: JSON.stringify(componentsInternalInfo),
     BLOCKLET_MODE: blocklet.mode || BLOCKLET_MODES.PRODUCTION,
     BLOCKLET_APP_EK: tmp?.secretKey,

package/lib/util/launcher.js

@@ -2,6 +2,7 @@ const path = require('path');
 const fs = require('fs-extra');
 const joinUrl = require('url-join');
 const pick = require('lodash/pick');
+const isEmpty = require('lodash/isEmpty');
 const {
   getUserAvatarUrl,
   extractUserAvatar,
@@ -17,7 +18,7 @@ const { getLauncherUser, getLauncherSession: getLauncherSessionRaw, doRequest }
 const { createAuthToken, getPassportStatusEndpoint } = require('@abtnode/auth/lib/auth');
 const { createPassportVC, createPassport, createUserPassport } = require('@abtnode/auth/lib/passport');
 
-const { BlockletStatus, LOGIN_PROVIDER } = require('@blocklet/constant');
+const { LOGIN_PROVIDER } = require('@blocklet/constant');
 const {
   WELLKNOWN_SERVICE_PATH_PREFIX,
   NODE_DATA_DIR_NAME,
@@ -88,8 +89,12 @@ const setupAppOwner = async (node, sessionId) => {
   if (!blocklet) {
     throw new Error(`Blocklet not found in server: ${appDid}`);
   }
-  if (blocklet.status !== BlockletStatus.installed) {
-    throw new Error(`Blocklet status not expected: ${appDid}`);
+
+  // 安装后 blocklet.environments 可能不会立即有值，可以从 node.getBlockletEnvironments 获取
+  if (isEmpty(blocklet.environments)) {
+    const { all } = await node.getBlockletEnvironments(appDid);
+
+    blocklet.environments = all;
   }
 
   const { wallet } = getBlockletInfo(blocklet, info.sk);
@@ -193,8 +198,6 @@ const setupAppOwner = async (node, sessionId) => {
   });
 
   await node.setBlockletOwner({ did: appDid, owner: { did: ownerDid, pk: ownerPk } });
-  await node.endSession({ id: sessionId });
-  logger.info('Complete install for blocklet', { appDid, ownerDid, sessionId });
 
   return {
     session,

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.20-beta-cf6dfce1",
+  "version": "1.16.20-beta-148929e2",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,19 +19,19 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.16.20-beta-cf6dfce1",
-    "@abtnode/auth": "1.16.20-beta-cf6dfce1",
-    "@abtnode/certificate-manager": "1.16.20-beta-cf6dfce1",
-    "@abtnode/constant": "1.16.20-beta-cf6dfce1",
-    "@abtnode/cron": "1.16.20-beta-cf6dfce1",
-    "@abtnode/logger": "1.16.20-beta-cf6dfce1",
-    "@abtnode/models": "1.16.20-beta-cf6dfce1",
-    "@abtnode/queue": "1.16.20-beta-cf6dfce1",
-    "@abtnode/rbac": "1.16.20-beta-cf6dfce1",
-    "@abtnode/router-provider": "1.16.20-beta-cf6dfce1",
-    "@abtnode/static-server": "1.16.20-beta-cf6dfce1",
-    "@abtnode/timemachine": "1.16.20-beta-cf6dfce1",
-    "@abtnode/util": "1.16.20-beta-cf6dfce1",
+    "@abtnode/analytics": "1.16.20-beta-148929e2",
+    "@abtnode/auth": "1.16.20-beta-148929e2",
+    "@abtnode/certificate-manager": "1.16.20-beta-148929e2",
+    "@abtnode/constant": "1.16.20-beta-148929e2",
+    "@abtnode/cron": "1.16.20-beta-148929e2",
+    "@abtnode/logger": "1.16.20-beta-148929e2",
+    "@abtnode/models": "1.16.20-beta-148929e2",
+    "@abtnode/queue": "1.16.20-beta-148929e2",
+    "@abtnode/rbac": "1.16.20-beta-148929e2",
+    "@abtnode/router-provider": "1.16.20-beta-148929e2",
+    "@abtnode/static-server": "1.16.20-beta-148929e2",
+    "@abtnode/timemachine": "1.16.20-beta-148929e2",
+    "@abtnode/util": "1.16.20-beta-148929e2",
     "@arcblock/did": "1.18.103",
     "@arcblock/did-auth": "1.18.103",
     "@arcblock/did-ext": "^1.18.103",
@@ -42,11 +42,11 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.18.103",
     "@arcblock/vc": "1.18.103",
-    "@blocklet/constant": "1.16.20-beta-cf6dfce1",
-    "@blocklet/env": "1.16.20-beta-cf6dfce1",
-    "@blocklet/meta": "1.16.20-beta-cf6dfce1",
-    "@blocklet/resolver": "1.16.20-beta-cf6dfce1",
-    "@blocklet/sdk": "1.16.20-beta-cf6dfce1",
+    "@blocklet/constant": "1.16.20-beta-148929e2",
+    "@blocklet/env": "1.16.20-beta-148929e2",
+    "@blocklet/meta": "1.16.20-beta-148929e2",
+    "@blocklet/resolver": "1.16.20-beta-148929e2",
+    "@blocklet/sdk": "1.16.20-beta-148929e2",
     "@did-space/client": "^0.3.41",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.103",
@@ -101,5 +101,5 @@
     "jest": "^27.5.1",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "bc2f0c9c5a39b124c7a7b64ec907527b3e8ccdf1"
+  "gitHead": "99e23380f73b63a8e63ce1fe8f75908194df5d80"
 }