@abtnode/core 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/states/challenge.js

@@ -9,17 +9,17 @@ class ChallengeState extends BaseState {
   /**
    * Creates an instance of ChallengeState
    * @param {string} baseDir
-   * @param {object} options
+   * @param {object} config
    * @memberof ChallengeState
    */
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'challenge.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'challenge.db', ...config });
   }
 
   generate() {
     return new Promise((resolve, reject) => {
       const challenge = stripHexPrefix(Mcrypto.getRandomBytes(16)).toUpperCase();
-      this.db.insert({ challenge }, (err, data) => {
+      this.insert({ challenge }, (err, data) => {
         if (err) {
           logger.error('generating error', { error: err });
           return reject(err);
@@ -38,7 +38,7 @@ class ChallengeState extends BaseState {
         return;
       }
 
-      this.db.findOne({ challenge }, (err, data) => {
+      this.findOne({ challenge }, (err, data) => {
         if (err) {
           logger.error('error find challenge', { error: err });
         }

package/lib/states/index.js

@@ -1,38 +1,35 @@
-const BaseState = require('./base');
+const stateFactory = require('@abtnode/db/lib/factory');
 const NodeState = require('./node');
 const ChallengeState = require('./challenge');
 const BlockletState = require('./blocklet');
 const NotificationState = require('./notification');
 const SiteState = require('./site');
-const HttpsCertState = require('./https-cert');
 const AccessKeyState = require('./access-key');
 const WebhookState = require('./webhook');
 const MigrationState = require('./migration');
 const SessionState = require('./session');
 const ExtrasState = require('./blocklet-extras');
 const CacheState = require('./cache');
+const AuditLogState = require('./audit-log');
 
-const states = {};
+const init = (dataDirs, config) => {
+  const notificationState = new NotificationState(dataDirs.core, config);
+  const nodeState = new NodeState(dataDirs.core, config, dataDirs, notificationState);
+  const blockletState = new BlockletState(dataDirs.core, config);
+  const challengeState = new ChallengeState(dataDirs.core, config);
+  const siteState = new SiteState(dataDirs.core, config);
+  const accessKeyState = new AccessKeyState(dataDirs.core, config);
+  const webhookState = new WebhookState(dataDirs.core, config);
+  const migrationState = new MigrationState(dataDirs.core, config);
+  const sessionState = new SessionState(dataDirs.core, config);
+  const extrasState = new ExtrasState(dataDirs.core, config);
+  const cacheState = new CacheState(dataDirs.core, config);
+  const auditLogState = new AuditLogState(dataDirs.core, config);
 
-const init = (dataDirs, options) => {
-  const notificationState = new NotificationState(dataDirs.core, options);
-  const nodeState = new NodeState(dataDirs.core, options, dataDirs, notificationState);
-  const blockletState = new BlockletState(dataDirs.core, options);
-  const challengeState = new ChallengeState(dataDirs.core, options);
-  const siteState = new SiteState(dataDirs.core, options);
-  const httpsCertState = new HttpsCertState(dataDirs.core, options);
-  const accessKeyState = new AccessKeyState(dataDirs.core, options);
-  const webhookState = new WebhookState(dataDirs.core, options);
-  const migrationState = new MigrationState(dataDirs.core, options);
-  const sessionState = new SessionState(dataDirs.core, options);
-  const extrasState = new ExtrasState(dataDirs.core, options);
-  const cacheState = new CacheState(dataDirs.core, options);
-
-  Object.assign(states, {
+  return {
     node: nodeState,
     blocklet: blockletState,
     notification: notificationState,
-    certificate: httpsCertState,
     site: siteState,
     accessKey: accessKeyState,
     webhook: webhookState,
@@ -41,22 +38,8 @@ const init = (dataDirs, options) => {
     session: sessionState,
     blockletExtras: extrasState,
     cache: cacheState,
-  });
+    auditLog: auditLogState,
+  };
 };
 
-module.exports = new Proxy(
-  {},
-  {
-    get(target, prop) {
-      if (prop === 'init') {
-        return init;
-      }
-
-      if (states[prop] instanceof BaseState) {
-        return states[prop];
-      }
-
-      throw new Error(`State ${String(prop)} may not be initialized`);
-    },
-  }
-);
+module.exports = stateFactory(init);

package/lib/states/migration.js

@@ -4,14 +4,14 @@ const logger = require('@abtnode/logger')('@abtnode/core:states:migration');
 const BaseState = require('./base');
 
 class MigrationState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'migration.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'migration.db', ...config });
   }
 
   // eslint-disable-next-line no-unused-vars
   async isExecuted({ script, version }, context) {
     try {
-      const item = await this.asyncDB.findOne({ script, version });
+      const item = await this.findOne({ script, version });
       return !!item;
     } catch (err) {
       logger.error('failed to find migration', { script, version });
@@ -22,7 +22,7 @@ class MigrationState extends BaseState {
   // eslint-disable-next-line no-unused-vars
   async markExecuted({ script, version }, context) {
     try {
-      const result = await this.asyncDB.insert({ script, version, executedAt: new Date() });
+      const result = await this.insert({ script, version, executedAt: new Date() });
       logger.info('mark executed', result);
       return result;
     } catch (error) {

package/lib/states/node.js

@@ -1,10 +1,11 @@
 /* eslint-disable no-underscore-dangle */
+const semver = require('semver');
 const omit = require('lodash/omit');
-const isEqual = require('lodash/isEqual');
 const isEmpty = require('lodash/isEmpty');
+const security = require('@abtnode/util/lib/security');
 const { isFromPublicKey } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:node');
-const { ROUTER_PROVIDER_NONE, NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT } = require('@abtnode/constant');
+const { NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT, EVENTS, SERVER_STATUS } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
@@ -14,23 +15,23 @@ class NodeState extends BaseState {
   /**
    * Creates an instance of NodeState.
    * @param {string} baseDir
-   * @param {object} options
+   * @param {object} config
    * @memberof NodeState
    */
-  constructor(baseDir, options = {}, dataDirs = {}, notification) {
-    super(baseDir, { filename: 'node.db', ...options });
+  constructor(baseDir, config = {}, dataDirs = {}, notification) {
+    super(baseDir, { filename: 'node.db', ...config });
 
     // Initialize the store
-    if (!options.nodeSk) {
+    if (!config.nodeSk) {
       throw new Error('Can not initialize node store without valid nodeSk');
     }
-    if (!options.nodePk) {
+    if (!config.nodePk) {
       throw new Error('Can not initialize node store without valid nodePk');
     }
-    if (!options.nodeDid) {
+    if (!config.nodeDid) {
       throw new Error('Can not initialize node store without valid nodeDid');
     }
-    if (!isFromPublicKey(options.nodeDid, options.nodePk)) {
+    if (!isFromPublicKey(config.nodeDid, config.nodePk)) {
       throw new Error('Node pk and did does not match');
     }
 
@@ -38,7 +39,7 @@ class NodeState extends BaseState {
     this.notification = notification;
 
     this.onReady(() => {
-      this.db.ensureIndex({ fieldName: 'did', unique: true }, (err) => {
+      this.ensureIndex({ fieldName: 'did', unique: true }, (err) => {
         if (err) {
           console.error('Failed to ensure unique index', err);
         }
@@ -47,7 +48,10 @@ class NodeState extends BaseState {
   }
 
   isInitialized(doc) {
-    return !!doc.nodeOwner;
+    const isOwnerConnected = !!doc.nodeOwner;
+    const isControlledBy3rdParty =
+      !doc.enablePassportIssuance && Array.isArray(doc.trustedPassports) && doc.trustedPassports.length > 0;
+    return isOwnerConnected || isControlledBy3rdParty;
   }
 
   /**
@@ -58,7 +62,8 @@ class NodeState extends BaseState {
    */
   read() {
     return new Promise((resolve, reject) => {
-      this.db.findOne({ did: this.options.nodeDid }, (err, record) => {
+      const { nodeDid, dek } = this.config;
+      this.findOne({ did: nodeDid }, (err, record) => {
         if (err) {
           // eslint-disable-next-line no-console
           console.error(err);
@@ -66,6 +71,10 @@ class NodeState extends BaseState {
         }
 
         if (record) {
+          if (dek) {
+            record.sk = security.decrypt(record.sk, record.did, dek);
+          }
+
           return resolve(record);
         }
 
@@ -74,33 +83,37 @@ class NodeState extends BaseState {
           description,
           nodeSk,
           nodePk,
-          nodeDid,
           nodeOwner,
           port,
           version,
-          routing = { provider: ROUTER_PROVIDER_NONE },
+          routing = { provider: 'default' },
           docker,
           mode,
           runtimeConfig,
           ownerNft,
-          launcherInfo,
-        } = this.options;
+          launcher,
+          didRegistry,
+          didDomain,
+          enablePassportIssuance = true,
+          trustedPassports = [],
+          webWalletUrl,
+        } = this.config;
 
         if (nodeOwner && !validateOwner(nodeOwner)) {
           return reject(new Error('Node owner is invalid'));
         }
 
-        const initialized = this.isInitialized({ nodeOwner });
+        const initialized = this.isInitialized({ nodeOwner, enablePassportIssuance, trustedPassports });
 
         return getDefaultConfigs()
           .then((defaultConfigs) =>
-            this.db.insert(
+            this.insert(
               {
                 ...(defaultConfigs || {}),
                 name,
                 description,
                 pk: nodePk,
-                sk: nodeSk,
+                sk: dek ? security.encrypt(nodeSk, nodeDid, dek) : nodeSk,
                 did: nodeDid,
                 initialized,
                 version,
@@ -111,11 +124,17 @@ class NodeState extends BaseState {
                 routing,
                 docker,
                 mode,
-                enableWelcomePage: true,
+                enableWelcomePage: mode !== NODE_MODES.SERVERLESS,
                 runtimeConfig,
                 ownerNft,
                 diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,
-                launcherInfo: launcherInfo || undefined,
+                launcher: launcher || undefined,
+                didRegistry,
+                didDomain,
+                enablePassportIssuance,
+                trustedPassports,
+                customBlockletNumber: 0,
+                webWalletUrl,
               },
               async (e, data) => {
                 if (e) {
@@ -128,6 +147,10 @@ class NodeState extends BaseState {
                 }
 
                 logger.info('create', { data });
+                if (dek) {
+                  data.sk = security.decrypt(data.sk, data.did, dek);
+                }
+
                 return resolve(data);
               }
             )
@@ -140,8 +163,8 @@ class NodeState extends BaseState {
   // FIXME: 这个接口比较危险，可能会修改一些本不应该修改的字段，后续需要考虑改进
   async updateNodeInfo(entity = {}) {
     const record = await this.read();
-    const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft']) });
-    this.emit('node.updated', updateResult, record);
+    const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft', 'sk']) });
+    this.emit(EVENTS.NODE_UPDATED, updateResult, record);
     return updateResult;
   }
 
@@ -151,14 +174,14 @@ class NodeState extends BaseState {
     }
 
     const nodeInfo = await this.updateNodeInfo({ routing: entity });
-    this.emit('routing.updated', nodeInfo);
+    this.emit(EVENTS.ROUTING_UPDATED, nodeInfo);
 
     return nodeInfo;
   }
 
-  cleanupDirtyUpgradeState() {
+  cleanupDirtyMaintainState() {
     return this.read().then((doc) => {
-      if (doc.nextVersion === doc.version) {
+      if (doc.nextVersion && semver.lte(doc.nextVersion, doc.version)) {
         const updates = { nextVersion: '', upgradeSessionId: '' };
 
         // FIXME: this may cause the node exit some mode unexpectedly if it is not being upgraded
@@ -174,33 +197,58 @@ class NodeState extends BaseState {
     });
   }
 
-  addNodeOwner(owner) {
-    if (owner && !validateOwner(owner)) {
+  async addOwner(owner, doc) {
+    const initialized = this.isInitialized({ nodeOwner: owner });
+
+    if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
+      this.notification.setDefaultReceiver(owner.did);
+    }
+
+    const updateResult = await this.update(doc._id, {
+      $set: { nodeOwner: owner, initialized, initializedAt: initialized ? new Date() : null },
+    });
+
+    this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
+
+    return updateResult;
+  }
+
+  async updateNodeOwner({ nodeOwner, ownerNft }) {
+    if (!validateOwner(nodeOwner)) {
       throw new Error('Node owner is invalid');
     }
 
-    return this.read().then(async (doc) => {
-      if (doc.nodeOwner) {
-        if (isEqual(owner, doc.nodeOwner)) {
-          return doc;
-        }
+    const doc = await this.read();
 
-        throw new Error('Cannot set owner because owner already exists');
-      }
+    const initialized = this.isInitialized({ nodeOwner });
 
-      const initialized = this.isInitialized({ nodeOwner: owner });
+    if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
+      this.notification.setDefaultReceiver(nodeOwner.did);
+    }
 
-      if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
-        this.notification.setDefaultReceiver(owner.did);
-      }
+    const entities = { nodeOwner, initialized, initializedAt: initialized ? new Date() : null };
+    if (ownerNft) {
+      entities.ownerNft = ownerNft;
+    }
 
-      const updateResult = await this.update(doc._id, {
-        $set: { nodeOwner: owner, initialized, initializedAt: initialized ? new Date() : null },
-      });
+    const updateResult = await this.update(doc._id, {
+      $set: entities,
+    });
+
+    this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
+
+    return updateResult;
+  }
+
+  async updateNftHolder(holder) {
+    if (!holder) {
+      throw new Error('NFT holder can not be empty');
+    }
 
-      this.emit('node.addedOwner', updateResult);
+    const doc = await this.read();
 
-      return updateResult;
+    return this.update(doc._id, {
+      $set: { 'ownerNft.holder': holder },
     });
   }
 
@@ -234,18 +282,59 @@ class NodeState extends BaseState {
     return this.updateNodeInfo({ previousMode: '', mode: info.previousMode });
   }
 
+  async setMode(mode) {
+    if (Object.values(NODE_MODES).includes(mode) === false) {
+      throw new Error(`Can not update server to unsupported mode: ${mode}`);
+    }
+
+    return this.updateNodeInfo({ previousMode: '', mode });
+  }
+
   async getEnvironments() {
     return this.read().then((info) => ({
       ABT_NODE: info.version,
       ABT_NODE_DID: info.did,
+      ABT_NODE_SK: info.sk,
       ABT_NODE_PK: info.pk,
       ABT_NODE_PORT: info.port,
       ABT_NODE_SERVICE_PORT: process.env.ABT_NODE_SERVICE_PORT,
+      ABT_NODE_MODE: info.mode,
     }));
   }
 
-  getBlockletRegistry() {
-    return this.read().then((info) => info.blockletRegistryList.find((item) => item.selected).url);
+  // deprecated
+  async increaseCustomBlockletNumber() {
+    const { _id, customBlockletNumber = 0 } = await this.read();
+    const num = customBlockletNumber + 1;
+    await this.update(_id, { $set: { customBlockletNumber: num } });
+    return num;
+  }
+
+  async updateGateway(gateway) {
+    const [, nodeInfo] = await this.update(
+      {},
+      { $set: { 'routing.requestLimit': gateway.requestLimit, 'routing.cacheEnabled': gateway.cacheEnabled } }
+    );
+
+    this.emit(EVENTS.RELOAD_GATEWAY, nodeInfo);
+
+    return nodeInfo.routing;
+  }
+
+  async updateStatus(status) {
+    if (!Object.values(SERVER_STATUS).includes(status)) {
+      throw new Error('status is invalid');
+    }
+
+    const record = await this.read();
+    await this.update(record._id, { $set: { status } });
+
+    record.status = status;
+    return record;
+  }
+
+  async resetStatus() {
+    return this.updateStatus(SERVER_STATUS.RUNNING);
   }
 }
 

package/lib/states/notification.js

@@ -1,14 +1,15 @@
 const get = require('lodash/get');
 const logger = require('@abtnode/logger')('@abtnode/core:states:notification');
+const { EVENTS } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 
 class NotificationState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'notification.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'notification.db', ...config });
 
-    this.defaultSender = options.defaultSender || '';
-    this.defaultReceiver = options.defaultReceiver || '';
+    this.defaultSender = config.defaultSender || '';
+    this.defaultReceiver = config.defaultReceiver || '';
   }
 
   setDefaultSender(sender) {
@@ -27,7 +28,7 @@ class NotificationState extends BaseState {
     });
 
     return new Promise((resolve, reject) => {
-      this.db.insert(
+      this.insert(
         {
           sender: payload.sender || this.defaultSender,
           receiver: payload.receiver || this.defaultReceiver,
@@ -46,14 +47,14 @@ class NotificationState extends BaseState {
           }
 
           logger.info('create', { data });
-          this.emit('notification.create', data);
+          this.emit(EVENTS.NOTIFICATION_CREATE, data);
           return resolve(data);
         }
       );
     });
   }
 
-  async find({ receiver, sender, read, paging } = {}, context) {
+  async findPaginated({ receiver, sender, read, paging } = {}, context) {
     const conditions = {};
     // eslint-disable-next-line no-param-reassign
     receiver = receiver || get(context, 'user.did');
@@ -75,44 +76,30 @@ class NotificationState extends BaseState {
   }
 
   // eslint-disable-next-line no-unused-vars
-  read({ id }, context) {
+  async read({ id }, context) {
     const idList = id.split(',').map((x) => x.trim());
     logger.info('mark notification as read', { idList });
 
-    return new Promise((resolve, reject) => {
-      this.db.update(
-        { _id: { $in: idList } },
-        { $set: { read: true } },
-        { multi: true, upsert: false, returnUpdatedDocs: false },
-        (err, numAffected) => {
-          if (err) {
-            return reject(err);
-          }
+    const [numAffected] = await this.update(
+      { _id: { $in: idList } },
+      { $set: { read: true } },
+      { multi: true, upsert: false, returnUpdatedDocs: false }
+    );
 
-          return resolve(numAffected);
-        }
-      );
-    });
+    return numAffected;
   }
 
   // eslint-disable-next-line no-unused-vars
-  unread({ id }, context) {
+  async unread({ id }, context) {
     const idList = Array.isArray(id) ? id : [id];
 
-    return new Promise((resolve, reject) => {
-      this.db.update(
-        { _id: { $in: idList } },
-        { $set: { read: false } },
-        { multi: true, upsert: false, returnUpdatedDocs: false },
-        (err, numAffected) => {
-          if (err) {
-            return reject(err);
-          }
+    const [numAffected] = await this.update(
+      { _id: { $in: idList } },
+      { $set: { read: false } },
+      { multi: true, upsert: false, returnUpdatedDocs: false }
+    );
 
-          return resolve(numAffected);
-        }
-      );
-    });
+    return numAffected;
   }
 }
 

package/lib/states/session.js

@@ -5,18 +5,26 @@ const BaseState = require('./base');
  * This db is used to save session data generated in a http session. the session is NOT user auth session.
  */
 class SessionState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'session.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'session.db', ...config });
 
-    this.db.ensureIndex({ fieldName: 'createdAt' }, (error) => {
-      if (error) {
-        logger.error('ensure index failed', { error });
-      }
+    this.onReady(() => {
+      this.ensureIndex({ fieldName: 'createdAt' }, (error) => {
+        if (error) {
+          logger.error('ensure createdAt index failed', { error });
+        }
+      });
+
+      this.ensureIndex({ fieldName: 'expireDate', expireAfterSeconds: 0 }, (error) => {
+        if (error) {
+          logger.error('ensure expireDate index failed', { error });
+        }
+      });
     });
   }
 
   async start(initialData) {
-    const { _id, ...data } = await this.asyncDB.insert(initialData);
+    const { _id, ...data } = await this.insert(initialData);
     return { id: _id, ...data };
   }
 
@@ -29,7 +37,7 @@ class SessionState extends BaseState {
 
     // eslint-disable-next-line no-underscore-dangle
     delete exist._id;
-    await this.asyncDB.update({ _id: id }, { $set: { ...exist, ...data } }, { multi: false, upsert: false });
+    await super.update({ _id: id }, { $set: { ...exist, ...data } }, { multi: false, upsert: false });
 
     return { id, ...exist, ...data };
   }
@@ -51,7 +59,7 @@ class SessionState extends BaseState {
       throw new Error(`Session does not exist: ${id}`);
     }
 
-    await this.asyncDB.remove({ _id: id });
+    await this.remove({ _id: id });
 
     data.id = id;
     return data;