@abtnode/core 1.16.20-beta-28c66e0b → 1.16.20-beta-9c254d14

package/lib/blocklet/project/index.js

@@ -101,6 +101,24 @@ const deleteRelease = async ({ did, projectId, releaseId, manager }) => {
   await fs.remove(releaseDir);
 };
 
+const checkResourceExists = async (projectDir, action, releaseId) => {
+  const releaseDir =
+    action === 'create'
+      ? path.join(projectDir, PROJECT.RESOURCE_DIR)
+      : path.join(projectDir, PROJECT.RELEASE_DIR, `${releaseId}`, PROJECT.RESOURCE_DIR);
+
+  const configDir = path.join(releaseDir, COMPONENT_CONFIG_MAP_DIR);
+  const errMsg = 'resource should not be empty';
+  if (!fs.existsSync(configDir)) {
+    throw new Error(errMsg);
+  }
+
+  const files = await fs.readdir(configDir);
+  if (!files.length) {
+    throw new Error(errMsg);
+  }
+};
+
 const createRelease = async ({
   did,
   projectId,
@@ -164,6 +182,12 @@ const createRelease = async ({
 
   params.blockletDid = blockletDid;
 
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`);
+
+  if (status !== PROJECT.RELEASE_STATUS.draft) {
+    await checkResourceExists(projectDir, action, releaseId);
+  }
+
   const release = await releaseState.upsertRelease({
     ...params,
     projectId,
@@ -174,7 +198,6 @@ const createRelease = async ({
 
   const _releaseId = release.id;
 
-  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`);
   const tmpDir = path.join(manager.dataDirs.tmp, PROJECT.DIR, `${blockletDid}-${createRandomStr()}`);
   const releaseDir = path.join(projectDir, PROJECT.RELEASE_DIR, `${_releaseId}`);
   const resourceDir = path.join(releaseDir, PROJECT.RESOURCE_DIR);
@@ -251,7 +274,9 @@ const createRelease = async ({
 
     // create resource
     await fs.ensureDir(resourceDir);
-    await fs.copy(resourceDir, path.join(tmpBundleDir, 'resource'));
+    const tmpBundleResourceDir = path.join(tmpBundleDir, 'resource');
+    await fs.copy(resourceDir, tmpBundleResourceDir);
+    await fs.remove(path.join(tmpBundleResourceDir, COMPONENT_CONFIG_MAP_DIR));
 
     // create blocklet.yml
     const resourceList = await fs.readdir(resourceDir);
@@ -267,7 +292,7 @@ const createRelease = async ({
       logo: logoFileName,
       resources: resourcesPaths.length ? resourcesPaths : undefined,
       components: [],
-      files: ['screenshots'],
+      files: project.blockletScreenshots?.length ? ['screenshots'] : [],
       screenshots: project.blockletScreenshots || [],
     };
     await updateMetaFile(path.join(tmpBundleDir, BLOCKLET_META_FILE), meta);
@@ -362,8 +387,10 @@ const updateSelectedResources = async ({ did, projectId, releaseId, componentDid
     await fs.remove(file);
   }
 
-  await fs.ensureDir(path.dirname(file));
-  await fs.outputJSON(file, resources);
+  if (resources.length) {
+    await fs.ensureDir(path.dirname(file));
+    await fs.outputJSON(file, resources);
+  }
 };
 
 module.exports = {

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/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/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.20-beta-28c66e0b",
+  "version": "1.16.20-beta-9c254d14",
   "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-28c66e0b",
-    "@abtnode/auth": "1.16.20-beta-28c66e0b",
-    "@abtnode/certificate-manager": "1.16.20-beta-28c66e0b",
-    "@abtnode/constant": "1.16.20-beta-28c66e0b",
-    "@abtnode/cron": "1.16.20-beta-28c66e0b",
-    "@abtnode/logger": "1.16.20-beta-28c66e0b",
-    "@abtnode/models": "1.16.20-beta-28c66e0b",
-    "@abtnode/queue": "1.16.20-beta-28c66e0b",
-    "@abtnode/rbac": "1.16.20-beta-28c66e0b",
-    "@abtnode/router-provider": "1.16.20-beta-28c66e0b",
-    "@abtnode/static-server": "1.16.20-beta-28c66e0b",
-    "@abtnode/timemachine": "1.16.20-beta-28c66e0b",
-    "@abtnode/util": "1.16.20-beta-28c66e0b",
+    "@abtnode/analytics": "1.16.20-beta-9c254d14",
+    "@abtnode/auth": "1.16.20-beta-9c254d14",
+    "@abtnode/certificate-manager": "1.16.20-beta-9c254d14",
+    "@abtnode/constant": "1.16.20-beta-9c254d14",
+    "@abtnode/cron": "1.16.20-beta-9c254d14",
+    "@abtnode/logger": "1.16.20-beta-9c254d14",
+    "@abtnode/models": "1.16.20-beta-9c254d14",
+    "@abtnode/queue": "1.16.20-beta-9c254d14",
+    "@abtnode/rbac": "1.16.20-beta-9c254d14",
+    "@abtnode/router-provider": "1.16.20-beta-9c254d14",
+    "@abtnode/static-server": "1.16.20-beta-9c254d14",
+    "@abtnode/timemachine": "1.16.20-beta-9c254d14",
+    "@abtnode/util": "1.16.20-beta-9c254d14",
     "@arcblock/did": "1.18.103",
     "@arcblock/did-auth": "1.18.103",
     "@arcblock/did-ext": "^1.18.103",
@@ -42,12 +42,12 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.18.103",
     "@arcblock/vc": "1.18.103",
-    "@blocklet/constant": "1.16.20-beta-28c66e0b",
-    "@blocklet/env": "1.16.20-beta-28c66e0b",
-    "@blocklet/meta": "1.16.20-beta-28c66e0b",
-    "@blocklet/resolver": "1.16.20-beta-28c66e0b",
-    "@blocklet/sdk": "1.16.20-beta-28c66e0b",
-    "@did-space/client": "^0.3.40",
+    "@blocklet/constant": "1.16.20-beta-9c254d14",
+    "@blocklet/env": "1.16.20-beta-9c254d14",
+    "@blocklet/meta": "1.16.20-beta-9c254d14",
+    "@blocklet/resolver": "1.16.20-beta-9c254d14",
+    "@blocklet/sdk": "1.16.20-beta-9c254d14",
+    "@did-space/client": "^0.3.41",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.103",
     "@ocap/util": "1.18.103",
@@ -101,5 +101,5 @@
     "jest": "^27.5.1",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "c4c767c15f6f3c0972a466e262f00860878a90a3"
+  "gitHead": "2f74601e9a8f2e07e872a629b6abc8d4bc1fd371"
 }