@abtnode/certificate-manager 1.16.20-beta-cf6dfce1 → 1.16.20-beta-148929e2

package/libs/acme-manager.js

@@ -41,11 +41,11 @@ class Manager extends EventEmitter {
           return;
         }
 
-        await this._createOrRenewCert({ ...data, challenges: { 'http-01': http01 } });
+        await this.createOrRenewCert({ ...data, challenges: { 'http-01': http01 } });
       },
       options: {
-        maxRetries: 0,
-        retryDelay: 60 * 1000,
+        maxRetries: process.env.NODE_ENV === 'production' ? 5 : 0,
+        retryDelay: 10 * 1000,
         maxTimeout: 60 * 1000, // throw timeout error after 1 minutes
         id: (job) => this.getJobId(job),
       },
@@ -61,17 +61,41 @@ class Manager extends EventEmitter {
     };
   }
 
-  async pushToJobQueue(domain) {
-    const jobData = { domain, subscriberEmail: this.maintainerEmail };
+  /*
+   * @param {string} domain
+   * @param {object} options
+   * @param {number} options.delay - delay time in ms
+   * @return {Promise<void>}
+   */
+  async pushToJobQueue(domain, { delay = 0, metadata } = {}) {
+    const jobData = { domain, subscriberEmail: this.maintainerEmail, delay, metadata };
 
     const job = await this.queue.get(this.getJobId(jobData));
 
     if (!job) {
-      this.queue.push(jobData);
+      const newJob = this.queue.push(jobData);
+      newJob.on('failed', async (data) => {
+        const tmpDomain = data?.job?.domain;
+        if (tmpDomain) {
+          await states.certificate.updateStatus(tmpDomain, CERT_STATUS.error);
+        }
+
+        this.emit('cert.error', data.job);
+        logger.error(`create certificate for ${tmpDomain} job failed`, { domain: tmpDomain, error: data.error });
+      });
     }
   }
 
-  async add(domain) {
+  /**
+   *
+   * @param {object} data
+   * @param {string} data.domain
+   * @param {string} data.siteId
+   * @param {object} options
+   * @param {number} options.delay - delay time in ms
+   * @returns
+   */
+  async add({ domain, siteId }, { delay = 0, metadata } = {}) {
     if (!domain) {
       throw new Error('domain is required when add domain');
     }
@@ -80,13 +104,13 @@ class Manager extends EventEmitter {
     if (!cert) {
       cert = await states.certificate.insert({
         domain,
+        siteId,
         source: CERT_SOURCE.letsEncrypt,
         status: CERT_STATUS.waiting,
       });
     }
 
-    await this.pushToJobQueue(domain);
-
+    await this.pushToJobQueue(domain, { delay, metadata });
     return cert;
   }
 
@@ -111,7 +135,7 @@ class Manager extends EventEmitter {
     };
   }
 
-  async _createOrRenewCert({ domain, subscriberEmail, force = false, challenges }) {
+  async createOrRenewCert({ domain, subscriberEmail, force = false, challenges, metadata }) {
     try {
       if (!domain) {
         throw new Error('domain is required when create certificate');
@@ -120,7 +144,7 @@ class Manager extends EventEmitter {
       const cert = await states.certificate.findOne({ domain });
       if (!cert) {
         logger.warn(`create certificate failed: the cert ${domain} does not exist`);
-        return;
+        return null;
       }
 
       let status = CERT_STATUS.creating;
@@ -131,18 +155,41 @@ class Manager extends EventEmitter {
 
         if (force === false && days > this.renewalOffsetInDay) {
           logger.info(`no need to renewal ${cert.domain}, the certificate will expires more than ${days} days`);
-          return;
+          return null;
         }
 
         status = CERT_STATUS.renewaling;
       }
 
       await states.certificate.updateStatus(cert.domain, status);
-      await this.acme.create({
+      const data = await this.acme.create({
         subject: cert.domain,
         subscriberEmail,
         challenges,
       });
+
+      logger.info(`create certificate for ${domain} job success`);
+
+      const [count, certs] = await states.certificate.update(
+        { domain: data.subject },
+        {
+          $set: {
+            domain: data.subject,
+            status: CERT_STATUS.generated,
+            certificate: data.fullchain,
+            privateKey: data.privkey,
+          },
+        }
+      );
+
+      if (count === 0) {
+        throw new Error(`update certificate for ${domain} failed`);
+      }
+
+      logger.info(`updated ${count} certificate for ${domain} job success`);
+
+      this.emit('cert.issued', { id: cert.id, domain: data.subject, metadata });
+      return certs[0];
     } catch (error) {
       logger.error(`create certificate for ${domain} job failed`, error);
       throw error;
@@ -151,7 +198,11 @@ class Manager extends EventEmitter {
 
   async checkRenewalCerts() {
     logger.info('run renewal certificate job');
+
     const certs = await states.certificate.findRenewCerts(this.renewalOffsetInDay);
+
+    logger.info(`found ${certs.length} certs need to renewal`);
+
     for (const cert of certs) {
       // eslint-disable-next-line no-await-in-loop
       await this.pushToJobQueue(cert.domain);
@@ -177,31 +228,6 @@ Manager.getInstance = async ({ maintainerEmail, baseDataDir }) => {
 
   await instance.acme.init();
 
-  instance.acme.on('cert.issued', async (data) => {
-    await states.certificate.update(
-      { domain: data.subject },
-      {
-        $set: {
-          domain: data.subject,
-          status: CERT_STATUS.generated,
-          certificate: data.fullchain,
-          privateKey: data.privkey,
-        },
-      }
-    );
-
-    const cert = await states.certificate.findOne({ domain: data.subject });
-    instance.emit('cert.issued', { id: cert.id, domain: cert.domain });
-  });
-
-  instance.acme.on('cert.error', async (data) => {
-    if (data.domain) {
-      await states.certificate.updateStatus(data.domain, CERT_STATUS.error);
-    }
-
-    instance.emit('cert.error', data);
-  });
-
   return instance;
 };
 

package/libs/acme-wrapper.js

@@ -85,17 +85,20 @@ class AcmeWrapper extends EventEmitter {
 
       logger.info('certificates generated!');
 
-      this.emit('cert.issued', {
+      const data = {
         subject,
         privkey: serverPem,
         cert: pems.cert,
         chain: pems.chain,
         fullchain,
         challenges,
-      });
+      };
+
+      return data;
     } catch (error) {
       logger.error('create certificate error', { domain: subject, error });
       this.emit('cert.error', { domain: subject, error_message: error.message });
+      throw error;
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abtnode/certificate-manager",
-  "version": "1.16.20-beta-cf6dfce1",
+  "version": "1.16.20-beta-148929e2",
   "description": "Manage ABT Node SSL certificates",
   "author": "polunzh <polunzh@gmail.com>",
   "homepage": "https://github.com/ArcBlock/blocklet-server#readme",
@@ -32,11 +32,11 @@
     "url": "https://github.com/ArcBlock/blocklet-server/issues"
   },
   "dependencies": {
-    "@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/util": "1.16.20-beta-cf6dfce1",
+    "@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/util": "1.16.20-beta-148929e2",
     "@fidm/x509": "^1.2.1",
     "@greenlock/manager": "^3.1.0",
     "@root/acme": "^3.1.0",
@@ -49,5 +49,5 @@
     "lodash.get": "^4.4.2",
     "punycode": "^2.1.1"
   },
-  "gitHead": "bc2f0c9c5a39b124c7a7b64ec907527b3e8ccdf1"
+  "gitHead": "99e23380f73b63a8e63ce1fe8f75908194df5d80"
 }

package/sdk/manager.js

@@ -128,15 +128,19 @@ class Manager extends EventEmitter {
 
   /**
    * 生成域名，certificate-manager 会自动生成并更新该证书
-   * @param {string} domain
+   * @param {object} data
+   * @param {string} data.domain
+   * @param {string} data.siteId
+   * @param {object} options
+   * @param {number} options.delay - delay time in ms
    * @returns
    */
-  issue(domain) {
+  issue({ domain, siteId }, options) {
     if (!domain) {
       throw new Error('domain is required');
     }
 
-    return this.acmeManager.add(domain.toLowerCase());
+    return this.acmeManager.add({ domain: domain.toLowerCase(), siteId }, options);
   }
 
   async upsertByDomain(tmpData) {

package/states/certificate.js

@@ -17,6 +17,14 @@ class Certificate extends BaseState {
     return super.update({ domain }, { $set: { status } });
   }
 
+  updateStatusById(id, status) {
+    if (!Object.values(CERT_STATUS).includes(status)) {
+      throw new Error('invalid domain status');
+    }
+
+    return super.update({ id }, { $set: { status } });
+  }
+
   insert(data) {
     if (data.certificate) {
       data.meta = getCertInfo(data.certificate);