@abtnode/core 1.8.63 → 1.8.64-beta-0b5ede51

package/lib/api/team.js

@@ -408,6 +408,26 @@ class TeamAPI extends EventEmitter {
 
   // Invite member
 
+  /**
+   * @type InvitationSession {
+   *   type: 'invite';
+   *   role: string;
+   *   remark: string;
+   *   expireDate: number;
+   *   inviter: {
+   *     did: string;
+   *     email?: string;
+   *     fullName?: string;
+   *     role?: string;
+   *   };
+   *   teamDid: string;
+   *   status: '' | 'success';
+   *   receiver: {
+   *     did: string;
+   *   };
+   * }
+   * @returns
+   */
   async createMemberInvitation({ teamDid, role, expireTime, remark }, context) {
     await this.teamManager.checkEnablePassportIssuance(teamDid);
 
@@ -484,15 +504,17 @@ class TeamAPI extends EventEmitter {
       expireDate: new Date(invitation.expireDate).toString(),
       inviter: invitation.inviter,
       teamDid: invitation.teamDid,
+      status: invitation.status,
+      receiver: invitation.receiver,
     };
   }
 
-  async getInvitations({ teamDid }) {
+  async getInvitations({ teamDid, filter }) {
     const state = await this.getSessionState(teamDid);
 
     const invitations = await state.find({ type: 'invite' });
 
-    return invitations.map((d) => ({
+    return invitations.filter(filter || ((x) => x.status !== 'success')).map((d) => ({
       // eslint-disable-next-line no-underscore-dangle
       inviteId: d._id,
       role: d.role,
@@ -500,6 +522,8 @@ class TeamAPI extends EventEmitter {
       expireDate: new Date(d.expireDate).toString(),
       inviter: d.inviter,
       teamDid: d.teamDid,
+      status: d.status,
+      receiver: d.receiver,
     }));
   }
 
@@ -516,7 +540,7 @@ class TeamAPI extends EventEmitter {
     return true;
   }
 
-  async processInvitation({ teamDid, inviteId }) {
+  async checkInvitation({ teamDid, inviteId }) {
     const state = await this.getSessionState(teamDid);
 
     const invitation = await state.read(inviteId);
@@ -538,16 +562,33 @@ class TeamAPI extends EventEmitter {
       throw new Error(`Role does not exist: ${role}`);
     }
 
-    await state.end(inviteId);
-
-    logger.info('Invitation session completed successfully', { inviteId, role });
-
     return {
       role,
       remark,
     };
   }
 
+  async closeInvitation({ teamDid, inviteId, status, receiver, timeout = 30 * 1000 }) {
+    const state = await this.getSessionState(teamDid);
+
+    const invitation = await state.read(inviteId);
+
+    if (!invitation) {
+      throw new Error(`The invitation does not exist: ${inviteId}`);
+    }
+
+    await state.update(inviteId, { status, receiver });
+
+    setTimeout(async () => {
+      try {
+        logger.info('Invitation session closed', { inviteId });
+        await state.end(inviteId);
+      } catch (error) {
+        logger.error('close invitation failed', { error });
+      }
+    }, timeout);
+  }
+
   // Issue Passport
 
   async createPassportIssuance({ teamDid, ownerDid, name }) {

package/lib/blocklet/manager/disk.js

@@ -134,6 +134,8 @@ const handleInstanceInStore = require('../../util/public-to-store');
 const { getNFTState, getServerDidDomain } = require('../../util');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
+const { SpacesBackup } = require('../storage/backup/spaces');
+const { SpacesRestore } = require('../storage/restore/spaces');
 const installFromBackup = require('./helper/install-from-backup');
 
 const {
@@ -609,6 +611,35 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').BackupToSpacesParams} input
+   * @memberof BlockletManager
+   */
+  async backupToSpaces(input) {
+    const spacesBackup = new SpacesBackup(input);
+    await spacesBackup.backup();
+  }
+
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').RequestRestoreFromSpacesInput} input
+   * @memberof BlockletManager
+   */
+  async restoreFromSpaces(input) {
+    const spacesRestore = new SpacesRestore(input);
+    await spacesRestore.restore();
+
+    // FIXME: 需要改成队列执行，本次失败，下次还需要重试，页面刷新后也能知道最新的状态
+    await this._installFromBackup({
+      url: `file://${spacesRestore.blockletRestoreDir}`,
+      blockletSecretKey: spacesRestore.blockletWallet.secretKey,
+      moveDir: true,
+    });
+  }
+
   async restart({ did }, context) {
     logger.info('restart blocklet', { did });
 
@@ -1617,6 +1648,11 @@ class BlockletManager extends BaseBlockletManager {
    *  /data
    *  /blocklet.json
    *  /blocklet_extras.json
+   * @see Blocklet 端到端备份方案的设计与实现（一期） https://team.arcblock.io/comment/discussions/e62084d5-fafa-489e-91d5-defcd6e93223
+   * @param {{ url: string, blockletSecretKey: string, moveDir: boolean}} [{ url }={}]
+   * @param {Record<string, string>} [context={}]
+   * @return {Promise<any>}
+   * @memberof BlockletManager
    */
   async _installFromBackup({ url, blockletSecretKey, moveDir } = {}, context = {}) {
     return installFromBackup({ url, blockletSecretKey, moveDir, context, manager: this, states });
@@ -2090,10 +2126,9 @@ class BlockletManager extends BaseBlockletManager {
 
     if (controller?.nftId) {
       // sometimes nedb will throw error if use states.blocklet.count({ ['controller.nftId']: controller.nftId })
-      const blocklets = await states.blocklet.find({}, { controller: 1 });
-      const count = blocklets.filter((x) => x.controller?.nftId === controller.nftId).length;
+      const installedCount = await states.blockletExtras.count({ 'controller.nftId': controller.nftId });
 
-      if (count >= (controller.appMaxCount || 1)) {
+      if (installedCount >= (controller.appMaxCount || 1)) {
         throw new Error(
           `You can only install ${controller.appMaxCount} blocklet with this credential: ${controller.nftId}`
         );
@@ -2691,7 +2726,6 @@ class BlockletManager extends BaseBlockletManager {
         source,
         deployedFrom,
         children,
-        controller,
       });
 
       await validateBlocklet(blocklet);
@@ -3798,7 +3832,8 @@ class BlockletManager extends BaseBlockletManager {
 
   async _createNotification(did, notification) {
     try {
-      const isExternal = await states.blocklet.isExternalBlocklet(did);
+      const extra = await states.blockletExtras.getMeta(did);
+      const isExternal = !!extra?.controller;
 
       if (isExternal) {
         return;

package/lib/blocklet/storage/backup/audit-log.js

@@ -0,0 +1,27 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { join } = require('path');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+/**
+ *
+ *
+ * @class AuditLogBackup
+ */
+class AuditLogBackup extends BaseBackup {
+  filename = 'audit-log.json';
+
+  async export() {
+    /**
+     * @type {import('@abtnode/client').AuditLog}
+     */
+    const auditLogs = await states.auditLog.find({
+      scope: this.blocklet.meta.did,
+    });
+
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), auditLogs);
+  }
+}
+
+module.exports = { AuditLogBackup };

package/lib/blocklet/storage/backup/base.js

@@ -0,0 +1,63 @@
+class BaseBackup {
+  /**
+   *
+   * @type {import('./spaces').SpaceBackupInput}
+   * @memberof BaseBackup
+   */
+  input;
+
+  /**
+   * @description blocklet state 对象
+   * @type {import('@abtnode/client').BlockletState}
+   * @memberof BaseBackup
+   */
+  blocklet;
+
+  /**
+   * @description 当前 blocklet 的数据目录
+   * @type {string}
+   * @memberof BaseBackup
+   */
+  blockletBackupDir;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {import('@ocap/wallet').WalletObject}
+   * @memberof BaseBackup
+   */
+  blockletWallet;
+
+  /**
+   *
+   * @description server 的数据目录
+   * @type {string}
+   * @memberof BaseBackup
+   */
+  serverDataDir;
+
+  constructor(input) {
+    this.input = input;
+  }
+
+  /**
+   *
+   *
+   * @param {import('./spaces').SpacesBackup} spacesBackup
+   * @memberof BaseBackup
+   */
+  ensureParams(spacesBackup) {
+    this.blocklet = spacesBackup.blocklet;
+    this.serverDataDir = spacesBackup.serverDataDir;
+    this.blockletBackupDir = spacesBackup.blockletBackupDir;
+    this.blockletWallet = spacesBackup.blockletWallet;
+  }
+
+  async export() {
+    throw new Error('not implemented');
+  }
+}
+
+module.exports = {
+  BaseBackup,
+};

package/lib/blocklet/storage/backup/blocklet-extras.js

@@ -0,0 +1,105 @@
+const { removeSync, outputJsonSync, readFileSync } = require('fs-extra');
+const { isEmpty, cloneDeep } = require('lodash');
+const { join } = require('path');
+const security = require('@abtnode/util/lib/security');
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+class BlockletExtrasBackup extends BaseBackup {
+  filename = 'blocklet-extras.json';
+
+  async export() {
+    const blockletExtra = await this.getBlockletExtra();
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), blockletExtra);
+  }
+
+  /**
+   *
+   * @description
+   * @return {Promise<import('@abtnode/client').BlockletState>}
+   * @memberof BlockletExtrasBackup
+   */
+  async getBlockletExtra() {
+    /**
+     * @type {import('@abtnode/client').BlockletState}
+     */
+    const blockletExtra = await states.blockletExtras.findOne({
+      did: this.blocklet.meta.did,
+    });
+    if (isEmpty(blockletExtra)) {
+      throw new Error('blockletExtra cannot be empty');
+    }
+
+    return this.cleanDate(blockletExtra);
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').BlockletState} blockletExtraInput
+   * @return {Promise<void>}
+   * @memberof BlockletExtrasBackup
+   */
+  async cleanDate(blockletExtraInput) {
+    const blockletExtra = cloneDeep(blockletExtraInput);
+
+    const queue = [blockletExtra];
+    while (queue.length) {
+      const currentBlockletExtra = queue.pop();
+
+      // 删除父 blocklet 的某些数据
+      if (currentBlockletExtra._id) {
+        delete currentBlockletExtra._id;
+        delete currentBlockletExtra.createdAt;
+        delete currentBlockletExtra.updatedAt;
+      }
+
+      // 加解密
+      this.useBlockletEncryptConfigs(currentBlockletExtra.configs);
+
+      if (currentBlockletExtra?.children) {
+        queue.push(...currentBlockletExtra.children);
+      }
+    }
+
+    return blockletExtra;
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').ConfigEntry[]} configs
+   * @return {void}
+   * @memberof BlockletExtrasBackup
+   */
+  useBlockletEncryptConfigs(configs) {
+    // 准备加解密所需的参数
+    // @see: https://github.com/ArcBlock/blocklet-server/blob/f561ba7290285f2e23dccb6d5323eb4d43c3cc3e/core/state/lib/index.js#L59
+    const dek = readFileSync(join(this.serverDataDir, '.sock'));
+
+    for (const config of configs) {
+      // 置空 blocklet 的密钥，但是保留其他属性，这很重要
+      if (config.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK) {
+        config.value = '';
+      } else if (config.secure) {
+        // secure 为 true 的配置才需要被加密保存上次到 did spaces
+
+        const encryptByServer = config.value;
+        // 先从 blocklet server 解密
+        // @see https://github.com/ArcBlock/blocklet-server/blob/f40338168a66893f325464cea79ae54c43f623b1/core/state/lib/blocklet/extras.js#L139
+        const decryptByServer = security.decrypt(encryptByServer, this.blocklet.meta.did, dek);
+        // 再用 blocklet secret 加密，然后才可以上传到 spaces
+        const encryptByBlocklet = security.encrypt(
+          decryptByServer,
+          this.blockletWallet.address,
+          Buffer.from(this.blockletWallet.secretKey)
+        );
+        config.value = encryptByBlocklet;
+      }
+    }
+  }
+}
+
+module.exports = { BlockletExtrasBackup };

package/lib/blocklet/storage/backup/blocklet.js

@@ -0,0 +1,53 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { cloneDeep } = require('lodash');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class BlockletBackup extends BaseBackup {
+  filename = 'blocklet.json';
+
+  async export() {
+    const blocklet = await this.cleanData();
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), blocklet);
+  }
+
+  /**
+   * @description 清理数据
+   * @see blocklet.db 中需要删除哪些字段呢？ https://github.com/ArcBlock/blocklet-server/issues/6120#issuecomment-1383798348
+   * @return {Promise<void>}
+   * @memberof BlockletBackup
+   */
+  async cleanData() {
+    const originalBlocklet = cloneDeep(this.blocklet);
+
+    /** @type {import('@abtnode/client').ComponentState[]} */
+    const queue = [originalBlocklet];
+
+    // 广度优先遍历
+    while (queue.length) {
+      const currentBlocklet = queue.pop();
+
+      // 父组件才需要删除的属性
+      if (currentBlocklet._id) {
+        delete currentBlocklet._id;
+        delete currentBlocklet.createdAt;
+        delete currentBlocklet.startedAt;
+        delete currentBlocklet.installedAt;
+      }
+
+      // 子组件和父组件都需要删除的属性
+      delete currentBlocklet.status;
+      delete currentBlocklet.ports;
+      delete currentBlocklet.environments;
+
+      if (currentBlocklet.children) {
+        queue.push(...currentBlocklet.children);
+      }
+    }
+
+    return originalBlocklet;
+  }
+}
+
+module.exports = { BlockletBackup };

package/lib/blocklet/storage/backup/blocklets.js

@@ -0,0 +1,80 @@
+const { removeSync, existsSync, ensureDirSync, createWriteStream } = require('fs-extra');
+const { join, dirname } = require('path');
+const archiver = require('archiver');
+const { BaseBackup } = require('./base');
+
+class BlockletsBackup extends BaseBackup {
+  /**
+   *
+   * @returns {Promise<void>}
+   * @memberof BlockletsBackup
+   */
+  async export() {
+    const blockletMetas = this.getBlockletMetas(this.blocklet);
+    const serverBlockletsDir = join(this.serverDataDir, 'blocklets');
+
+    const dirs = [];
+    for (const blockletMeta of blockletMetas) {
+      const sourceDir = join(serverBlockletsDir, blockletMeta.name, blockletMeta.version);
+      const destDir = join(blockletMeta.name, blockletMeta.version);
+      dirs.push({ sourceDir, destDir });
+    }
+
+    await this.dirsToZip(dirs, join(this.blockletBackupDir, 'blocklets.zip'));
+  }
+
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').BlockletState} blocklet
+   * @returns {Array<{name: string, version: string}>}
+   * @memberof BlockletsBackup
+   */
+  getBlockletMetas(blocklet) {
+    if (!blocklet?.meta?.bundleName || !blocklet?.meta?.version) {
+      return [];
+    }
+
+    const metas = [];
+    metas.push({
+      name: blocklet.meta.bundleName,
+      version: blocklet.meta.version,
+    });
+
+    for (const child of blocklet.children) {
+      metas.push(...this.getBlockletMetas(child));
+    }
+
+    return metas;
+  }
+
+  /**
+   * @param {Array<{sourceDir: string, destDir: string}>} dirs: /some/folder/to/compress
+   * @param {String} zipPath: /path/to/created.zip
+   * @returns {Promise}
+   * @memberof BlockletsBackup
+   */
+  async dirsToZip(dirs, zipPath) {
+    ensureDirSync(dirname(zipPath));
+    if (existsSync(zipPath)) {
+      removeSync(zipPath);
+    }
+
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const stream = createWriteStream(zipPath);
+
+    return new Promise((resolve, reject) => {
+      archive.on('error', (err) => reject(err));
+      stream.on('close', () => resolve());
+
+      for (const dir of dirs) {
+        archive.directory(dir.sourceDir, dir.destDir);
+      }
+
+      archive.pipe(stream);
+      archive.finalize();
+    });
+  }
+}
+
+module.exports = { BlockletsBackup };

package/lib/blocklet/storage/backup/data.js

@@ -0,0 +1,19 @@
+const { copySync } = require('fs-extra');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class DataBackup extends BaseBackup {
+  /**
+   *
+   * @returns {Promise<void>}
+   * @memberof BlockletsBackup
+   */
+  async export() {
+    const blockletDataDir = join(this.serverDataDir, 'data', this.blocklet.meta.name);
+    const blockletBackupDataDir = join(this.blockletBackupDir, 'data');
+
+    copySync(blockletDataDir, blockletBackupDataDir, { overwrite: true });
+  }
+}
+
+module.exports = { DataBackup };

package/lib/blocklet/storage/backup/logs.js

@@ -0,0 +1,23 @@
+const { ensureDirSync, copySync, statSync } = require('fs-extra');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class LogsBackup extends BaseBackup {
+  async export() {
+    const sourceLogsDir = join(this.serverDataDir, 'logs', this.blocklet.meta.name);
+    ensureDirSync(sourceLogsDir);
+
+    const targetLogsDir = join(this.blockletBackupDir, 'logs');
+
+    copySync(sourceLogsDir, targetLogsDir, {
+      overwrite: true,
+      filter: (src) => {
+        return !statSync(src).isSymbolicLink();
+      },
+    });
+  }
+}
+
+module.exports = {
+  LogsBackup,
+};

package/lib/blocklet/storage/backup/routing-rule.js

@@ -0,0 +1,19 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { join } = require('path');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+class RoutingRuleBackup extends BaseBackup {
+  filename = 'routing_rule.json';
+
+  async export() {
+    const routingRule = await states.site.findOne({
+      domain: `${this.blocklet.meta.did}.blocklet-domain-group`,
+    });
+
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), routingRule);
+  }
+}
+
+module.exports = { RoutingRuleBackup };