@abtnode/core 1.8.56 → 1.8.57

package/lib/blocklet/manager/disk.js

@@ -13,7 +13,7 @@ const { Throttle } = require('stream-throttle');
 const LRU = require('lru-cache');
 const joi = require('joi');
 const isUrl = require('is-url');
-const { isNFTExpired } = require('@abtnode/util/lib/nft');
+const { isNFTExpired, getNftExpirationDate } = require('@abtnode/util/lib/nft');
 const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
 const { isValid: isValidDid } = require('@arcblock/did');
@@ -2659,6 +2659,11 @@ class BlockletManager extends BaseBlockletManager {
         time: '0 */30 * * * *', // 30min
         fn: () => this._deleteExpiredExternalBlocklet(),
       },
+      {
+        name: 'clean-expired-blocklet-data',
+        time: '0 */20 0 * * *', // 每天凌晨 0 点的每 20 分钟
+        fn: () => this._cleanExpiredBlockletData(),
+      },
       {
         name: 'record-blocklet-runtime-history',
         time: `*/${MONITOR_RECORD_INTERVAL_SEC} * * * * *`, // 10s
@@ -2734,6 +2739,8 @@ class BlockletManager extends BaseBlockletManager {
 
       await validateBlocklet(blocklet);
 
+      await states.blockletExtras.addMeta({ did, meta: { did, name }, controller });
+
       await this._setConfigsFromMeta(did);
 
       logger.info('blocklet added to database', { did: meta.did });
@@ -3607,8 +3614,6 @@ class BlockletManager extends BaseBlockletManager {
   async _deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context) {
     const blocklet = await states.blocklet.getBlocklet(did);
     const { name } = blocklet.meta;
-    const dataDir = path.join(this.dataDirs.data, name);
-    const logsDir = path.join(this.dataDirs.logs, name);
     const cacheDir = path.join(this.dataDirs.cache, name);
 
     // Cleanup db
@@ -3616,19 +3621,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // Cleanup disk storage
     fs.removeSync(cacheDir);
-    if (keepData === false) {
-      fs.removeSync(dataDir);
-      fs.removeSync(logsDir);
-      await states.blockletExtras.remove({ did: blocklet.meta.did });
-    } else {
-      if (keepLogsDir === false) {
-        fs.removeSync(logsDir);
-      }
-
-      if (keepConfigs === false) {
-        await states.blockletExtras.remove({ did: blocklet.meta.did });
-      }
-    }
+    await this._cleanBlockletData({ blocklet, keepData, keepLogsDir, keepConfigs });
 
     const nodeInfo = await states.node.read();
     const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
@@ -3661,6 +3654,36 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
+  async _cleanBlockletData({ blocklet, keepData, keepLogsDir, keepConfigs }) {
+    const { name } = blocklet.meta;
+
+    const dataDir = path.join(this.dataDirs.data, name);
+    const logsDir = path.join(this.dataDirs.logs, name);
+
+    logger.info(`clean blocklet ${blocklet.meta.did} data`, { keepData, keepLogsDir, keepConfigs });
+
+    if (keepData === false) {
+      fs.removeSync(dataDir);
+      logger.info(`removed blocklet ${blocklet.meta.did} data dir: ${dataDir}`);
+
+      fs.removeSync(logsDir);
+      logger.info(`removed blocklet ${blocklet.meta.did} logs dir: ${logsDir}`);
+
+      await states.blockletExtras.remove({ did: blocklet.meta.did });
+      logger.info(`removed blocklet ${blocklet.meta.did} extra data`);
+    } else {
+      if (keepLogsDir === false) {
+        fs.removeSync(logsDir);
+        logger.info(`removed blocklet ${blocklet.meta.did} logs dir: ${logsDir}`);
+      }
+
+      if (keepConfigs === false) {
+        await states.blockletExtras.remove({ did: blocklet.meta.did });
+        logger.info(`removed blocklet ${blocklet.meta.did} extra data`);
+      }
+    }
+  }
+
   async _setConfigsFromMeta(did, childDid) {
     const blocklet = await getBlocklet({ states, dataDirs: this.dataDirs, did, validateEnv: false, ensureDirs: false });
 
@@ -3846,11 +3869,19 @@ class BlockletManager extends BaseBlockletManager {
               nftId: blocklet.controller.nftId,
             });
 
-            // FIXME: 后面需要考虑将数据保留一段时间
-            await this.delete({ did: blocklet.meta.did, keepData: false, keepConfigs: false, keepLogsDir: false });
+            await this.delete({ did: blocklet.meta.did, keepData: true, keepConfigs: true, keepLogsDir: true });
             logger.info('the expired blocklet already deleted', {
               blockletId: blocklet._id,
               nftId: blocklet.controller.nftId,
+              did: blocklet.meta.did,
+            });
+
+            const expiredAt = getNftExpirationDate(assetState);
+            await states.blockletExtras.updateExpireInfo({ did: blocklet.meta.did, expiredAt });
+            logger.info('updated expired blocklet extra info', {
+              blockletId: blocklet._id,
+              nftId: blocklet.controller.nftId,
+              did: blocklet.meta.did,
             });
           }
         } catch (error) {
@@ -3869,6 +3900,35 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
+  async _cleanExpiredBlockletData() {
+    try {
+      logger.info('start clean expired blocklet data');
+      const blockletExtras = await states.blockletExtras.getExpiredList();
+      if (blockletExtras.length === 0) {
+        logger.info('no expired blocklet data');
+        return;
+      }
+
+      const tasks = blockletExtras.map(async ({ did }) => {
+        const blocklet = await states.blocklet.getBlocklet(did);
+        await this._cleanBlockletData({ blocklet, keepData: false, keepLogsDir: false, keepConfigs: false });
+
+        this.emit(BlockletEvents.dataCleaned, {
+          blocklet,
+          keepRouting: false,
+        });
+
+        logger.info(`cleaned expired blocklet blocklet ${did} data`);
+      });
+
+      await Promise.all(tasks);
+
+      logger.info('clean expired blocklet data done');
+    } catch (error) {
+      logger.error('clean expired blocklet data failed', { error });
+    }
+  }
+
   async _updateDidDocument(blocklet) {
     const nodeInfo = await states.node.read();
 

package/lib/event.js

@@ -203,7 +203,7 @@ module.exports = ({
           logger.error('Failed to createAuditLog for upgradeBlocklet', { error });
         }
       }
-    } else if ([BlockletEvents.removed].includes(eventName)) {
+    } else if ([BlockletEvents.removed, BlockletEvents.dataCleaned].includes(eventName)) {
       await handleBlockletRemove(eventName, payload);
     } else if ([BlockletEvents.started].includes(eventName)) {
       const { publicToStore } = blocklet.settings || {};
@@ -306,7 +306,7 @@ module.exports = ({
     }
   });
 
-  listen(nodeState, EVENTS.NODE_UPGRADE_PROGRESS, onEvent);
+  listen(nodeState, EVENTS.NODE_MAINTAIN_PROGRESS, onEvent);
   nodeState.on(EVENTS.RELOAD_GATEWAY, (nodeInfo) => {
     handleRouting(nodeInfo).catch((err) => {
       logger.error('Handle routing failed on node.updated', { error: err });

package/lib/index.js

@@ -22,7 +22,7 @@ const Cert = require('./cert');
 
 const IP = require('./util/ip');
 const DomainStatus = require('./util/domain-status');
-const Upgrade = require('./util/upgrade');
+const Maintain = require('./util/maintain');
 const resetNode = require('./util/reset-node');
 const DiskMonitor = require('./util/disk-monitor');
 const StoreUtil = require('./util/store');
@@ -30,6 +30,7 @@ const createQueue = require('./queue');
 const createEvents = require('./event');
 const pm2Events = require('./blocklet/manager/pm2-events');
 const { createStateReadyQueue, createStateReadyHandler } = require('./util/ready');
+const { createDataArchive } = require('./util/blocklet');
 const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem, getStateCrons } = require('./util');
 
 /**
@@ -237,7 +238,7 @@ function ABTNode(options) {
     getNodeEnv: nodeAPI.getEnv.bind(nodeAPI),
     updateNodeInfo: nodeAPI.updateNodeInfo.bind(nodeAPI),
     getDelegationState: nodeAPI.getDelegationState.bind(nodeAPI),
-    cleanupDirtyUpgradeState: states.node.cleanupDirtyUpgradeState.bind(states.node),
+    cleanupDirtyMaintainState: states.node.cleanupDirtyMaintainState.bind(states.node),
     updateNodeOwner: states.node.updateNodeOwner.bind(states.node),
     updateNftHolder: states.node.updateNftHolder.bind(states.node),
     updateNodeRouting,
@@ -369,10 +370,11 @@ function ABTNode(options) {
     markMigrationExecuted: states.migration.markExecuted.bind(states.migration),
 
     // Upgrading
-    upgradeNodeVersion: Upgrade.startUpgrade,
-    checkNodeVersion: Upgrade.checkNewVersion,
-    isUpgrading: Upgrade.isUpgrading,
-    doUpgrade: Upgrade.doUpgrade,
+    upgradeNodeVersion: () => Maintain.triggerMaintain({ action: 'upgrade', next: Maintain.resumeMaintain }),
+    checkNodeVersion: Maintain.checkNewVersion,
+    restartServer: () => Maintain.triggerMaintain({ action: 'restart', next: Maintain.resumeMaintain }),
+    isBeingMaintained: Maintain.isBeingMaintained,
+    resumeMaintain: Maintain.resumeMaintain,
 
     // Session
     getSession: (params, context) => states.session.read(params.id, context),
@@ -390,6 +392,9 @@ function ABTNode(options) {
     getNodeRuntimeInfo: nodeAPI.getRealtimeData.bind(nodeAPI),
 
     getRouterProvider,
+
+    // for exporting blocklet data dir
+    createBlockletDataArchive: createDataArchive,
   };
 
   const events = createEvents({
@@ -415,7 +420,7 @@ function ABTNode(options) {
       context: { states, events, webhook },
       jobs: [
         IP.cron,
-        Upgrade.getCron(),
+        Maintain.getCron(),
         ...getRoutingCrons(),
         ...blockletManager.getCrons(),
         DiskMonitor.getCron(),
@@ -436,18 +441,15 @@ function ABTNode(options) {
 
   const createCLILog = (action) => {
     instance
-      .createAuditLog(
-        {
-          action,
-          args: {},
-          context: formatContext({
-            user: { fullName: 'CLI', role: 'admin', did: options.nodeDid },
-            headers: { 'user-agent': 'CLI' },
-          }),
-          result: null,
-        },
-        instance
-      )
+      .createAuditLog({
+        action,
+        args: {},
+        context: formatContext({
+          user: { fullName: 'CLI', role: 'admin', did: options.nodeDid },
+          headers: { 'user-agent': 'CLI' },
+        }),
+        result: null,
+      })
       .catch(console.error);
   };
 

package/lib/router/helper.js

@@ -33,6 +33,7 @@ const {
   WELLKNOWN_ACME_CHALLENGE_PREFIX,
   WELLKNOWN_DID_RESOLVER_PREFIX,
   WELLKNOWN_PING_PREFIX,
+  LOG_RETAIN_IN_DAYS,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
@@ -1024,7 +1025,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     const providerName = get(info, 'routing.provider', null);
 
     if (providerName && providers[providerName] && typeof providers[providerName].rotateLogs === 'function') {
-      await providers[providerName].rotateLogs();
+      await providers[providerName].rotateLogs({ retain: LOG_RETAIN_IN_DAYS });
     }
   };
 
@@ -1250,7 +1251,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       },
       {
         name: 'rotate-log-files',
-        time: '5 0 0 * * *', // rotate at 05:00 every day
+        time: '1 0 0 * * *', // rotate at 00:00:01 every day
         fn: rotateRouterLog,
         options: { runOnInit: false },
       },

package/lib/states/audit-log.js

@@ -208,6 +208,8 @@ const getLogContent = async (action, args, context, result, info, node) => {
       return `updated basic server settings: \n${Object.keys(args).map(x => `- ${x}: ${args[x]}`).join('\n')}`; // prettier-ignore
     case 'upgradeNodeVersion':
       return `upgrade server to ${info.nextVersion}`;
+    case 'restartServer':
+      return 'server was restarted';
     case 'startServer':
       return 'server was started';
     case 'stopServer':

package/lib/states/blocklet-extras.js

@@ -2,12 +2,15 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable consistent-return */
 const logger = require('@abtnode/logger')('state-blocklet-extras');
+const { EXPIRED_BLOCKLET_DATA_RETENTION_DAYS } = require('@abtnode/constant');
 const camelCase = require('lodash/camelCase');
 const get = require('lodash/get');
+const dayjs = require('dayjs');
 
 const BaseState = require('./base');
 
 const { mergeConfigs, parseConfigs } = require('../blocklet/extras');
+const { validateAddMeta, validateExpiredInfo } = require('../validators/blocklet-extra');
 
 const noop = (k) => (v) => v[k];
 
@@ -184,6 +187,33 @@ class BlockletExtrasState extends BaseState {
       return list;
     };
   }
+
+  async addMeta({ did, meta, controller } = {}) {
+    const entity = { did, meta };
+    if (controller) {
+      entity.controller = controller;
+    }
+
+    await validateAddMeta(entity);
+
+    return super.update({ did }, { $set: entity }, { upsert: true });
+  }
+
+  async updateExpireInfo({ did, expiredAt } = {}) {
+    const entity = { did, expiredAt };
+    await validateExpiredInfo(entity);
+
+    return super.update({ did }, { $set: { expiredAt } });
+  }
+
+  async getExpiredList() {
+    const now = dayjs();
+
+    return super.find({
+      'controller.nftId': { $exists: true },
+      expiredAt: { $exists: true, $lte: now.subtract(EXPIRED_BLOCKLET_DATA_RETENTION_DAYS, 'days').toISOString() },
+    });
+  }
 }
 
 module.exports = BlockletExtrasState;

package/lib/states/node.js

@@ -179,7 +179,7 @@ class NodeState extends BaseState {
     return nodeInfo;
   }
 
-  cleanupDirtyUpgradeState() {
+  cleanupDirtyMaintainState() {
     return this.read().then((doc) => {
       if (doc.nextVersion && semver.lte(doc.nextVersion, doc.version)) {
         const updates = { nextVersion: '', upgradeSessionId: '' };

package/lib/util/blocklet.js

@@ -11,6 +11,7 @@ const streamToPromise = require('stream-to-promise');
 const { Throttle } = require('stream-throttle');
 const ssri = require('ssri');
 const diff = require('deep-diff');
+const createArchive = require('archiver');
 const axios = require('@abtnode/util/lib/axios');
 const { stableStringify } = require('@arcblock/vc');
 
@@ -1492,6 +1493,26 @@ const consumeServerlessNFT = async ({ nftId, nodeInfo, blocklet }) => {
   }
 };
 
+const createDataArchive = (dataDir, fileName) => {
+  const zipPath = path.join(os.tmpdir(), fileName);
+  if (fs.existsSync(zipPath)) {
+    fs.removeSync(zipPath);
+  }
+
+  const archive = createArchive('zip', { zlib: { level: 9 } });
+  const stream = fs.createWriteStream(zipPath);
+
+  return new Promise((resolve, reject) => {
+    archive
+      .directory(dataDir, false)
+      .on('error', (err) => reject(err))
+      .pipe(stream);
+
+    stream.on('close', () => resolve(zipPath));
+    archive.finalize();
+  });
+};
+
 module.exports = {
   consumeServerlessNFT,
   forEachBlocklet,
@@ -1534,4 +1555,5 @@ module.exports = {
   getBlocklet,
   ensureEnvDefault,
   getConfigFromPreferences,
+  createDataArchive,
 };

package/lib/util/maintain.js

@@ -0,0 +1,233 @@
+/* eslint-disable no-param-reassign */
+const semver = require('semver');
+const sleep = require('@abtnode/util/lib/sleep');
+const SysInfo = require('systeminformation');
+const { NODE_MODES, NODE_MAINTAIN_PROGRESS, EVENTS } = require('@abtnode/constant');
+const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
+const Lock = require('@abtnode/util/lib/lock');
+const logger = require('@abtnode/logger')('@abtnode/core:maintain');
+
+const states = require('../states');
+const doRpc = require('./rpc');
+
+const lock = new Lock('node-upgrade-lock');
+
+// eslint-disable-next-line no-unused-vars
+const checkNewVersion = async (params, context) => {
+  try {
+    const info = await states.node.read();
+
+    if (!process.env.ABT_NODE_PACKAGE_NAME) {
+      logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
+      return '';
+    }
+
+    const versions = await listNpmPackageVersion(process.env.ABT_NODE_PACKAGE_NAME);
+    if (Array.isArray(versions) && versions.length) {
+      const latestVersion = versions[0].version;
+      if (semver.gt(latestVersion, info.version)) {
+        // if (semver.gte(latestVersion, info.version)) {
+        logger.info('New version found for Blocklet Server', {
+          latestVersion,
+          currentVersion: info.version,
+          nextVersion: info.nextVersion,
+        });
+        await states.node.updateNodeInfo({ nextVersion: latestVersion });
+        await states.notification.create({
+          title: 'Blocklet Server upgrade available',
+          description: 'A new and improved version of blocklet server is now available',
+          entityType: 'node',
+          severity: 'info',
+          sticky: true,
+          action: '/settings/about',
+        });
+
+        return latestVersion;
+      }
+    }
+
+    return '';
+  } catch (err) {
+    logger.error('Failed to check new version for Blocklet Server', { error: err });
+  }
+
+  return '';
+};
+
+const triggerMaintain = async ({ action, next }) => {
+  if (['upgrade', 'restart'].includes(action) === false) {
+    throw new Error(`Unrecognized server maintain action: ${action}`);
+  }
+
+  const info = await states.node.read();
+
+  if (action === 'upgrade') {
+    if (!info.nextVersion) {
+      throw new Error('Do nothing since there is no next version to upgrade');
+    }
+
+    // ensure we have enough memory for upgrading since the upgrading will consume a lot of memory
+    const { mem } = await SysInfo.get({ mem: '*' });
+    const freeMemory = mem.free / 1024 / 1024;
+    const availableMemory = mem.available / 1024 / 1024;
+    if (freeMemory < 200 && availableMemory < 300) {
+      throw new Error('Upgrade aborted because free memory not enough, please stop some blocklets and try again');
+    }
+  }
+
+  const from = info.version;
+  const to = action === 'upgrade' ? info.nextVersion : info.version;
+
+  // ensure we have an maintain session, we need a session to recover from crash
+  let sessionId = info.upgradeSessionId;
+  if (!sessionId) {
+    const result = await states.session.start({
+      action,
+      from,
+      to,
+      stage: NODE_MAINTAIN_PROGRESS.SETUP,
+      history: [],
+      startedAt: Date.now(),
+    });
+    sessionId = result.id;
+    logger.info(`generate new session for ${action}`, { from, to, sessionId });
+    await states.node.updateNodeInfo({ upgradeSessionId: sessionId });
+  }
+  const session = await states.session.read(sessionId);
+  if (!session) {
+    throw new Error(`${action} aborted due to invalid session: ${sessionId}`);
+  }
+
+  process.nextTick(async () => {
+    await next(session);
+  });
+
+  return sessionId;
+};
+
+const resumeMaintain = async (session) => {
+  await lock.acquire();
+
+  const sessionId = session.id;
+  const { action, from, to } = session;
+
+  const goNextState = async (stage, previousSucceed) => {
+    session = await states.session.update(sessionId, {
+      stage,
+      history: [...session.history, { stage: session.stage, succeed: previousSucceed }],
+    });
+    // Emit events so client will keep up
+    states.node.emit(EVENTS.NODE_MAINTAIN_PROGRESS, session);
+  };
+
+  // 1. enter maintenance mode
+  if (session.stage === NODE_MAINTAIN_PROGRESS.SETUP) {
+    logger.info('enter maintenance mode', { from, to, sessionId });
+    await states.node.enterMode(NODE_MODES.MAINTENANCE);
+    if (action === 'upgrade') {
+      await goNextState(NODE_MAINTAIN_PROGRESS.INSTALLING, true);
+    }
+    if (action === 'restart') {
+      await goNextState(NODE_MAINTAIN_PROGRESS.VERIFYING, true);
+    }
+  }
+
+  // 2. install new version
+  if (session.stage === NODE_MAINTAIN_PROGRESS.INSTALLING) {
+    const result = await doRpc({ command: 'install', version: to });
+    logger.info('new version installed', { from, to, sessionId });
+    if (result.code !== 0) {
+      await sleep(3000);
+    }
+    await goNextState(NODE_MAINTAIN_PROGRESS.VERIFYING, result.code === 0);
+  }
+
+  // 2. verify new version
+  if (session.stage === NODE_MAINTAIN_PROGRESS.VERIFYING) {
+    const result = await doRpc({ command: 'verify', version: to });
+    await sleep(3000);
+    if (result.code === 0) {
+      logger.info('new version verified', { from, to, sessionId });
+      await goNextState(NODE_MAINTAIN_PROGRESS.RESTARTING, true);
+    } else {
+      logger.info('new version verify failed', { from, to, sessionId });
+      await goNextState(NODE_MAINTAIN_PROGRESS.ROLLBACK, false);
+    }
+  }
+
+  // 4. reset node.nextVersion/upgradeSessionId and exit maintenance mode
+  if (session.stage === NODE_MAINTAIN_PROGRESS.ROLLBACK) {
+    logger.info('rollback', { from, to, sessionId });
+    await sleep(3000);
+    await goNextState(NODE_MAINTAIN_PROGRESS.COMPLETE, true);
+    await sleep(5000);
+    await states.node.updateNodeInfo({ nextVersion: '', version: from, upgradeSessionId: '' });
+    try {
+      await states.node.exitMode(NODE_MODES.MAINTENANCE);
+    } catch (error) {
+      logger.error('Failed to rollback', { error });
+    }
+    await lock.release();
+    return;
+  }
+
+  // 3. restarting update version in node config and state
+  if (session.stage === NODE_MAINTAIN_PROGRESS.RESTARTING) {
+    logger.info('restart server', { from, to, sessionId });
+    await sleep(3000);
+    await goNextState(NODE_MAINTAIN_PROGRESS.CLEANUP, true);
+    await sleep(3000);
+    await doRpc({ command: 'restart', dataDir: process.env.ABT_NODE_DATA_DIR });
+    await lock.release();
+    return; // we should abort here and resume after restart
+  }
+
+  // 4. reset node.nextVersion/upgradeSessionId and exit maintenance mode
+  if (session.stage === NODE_MAINTAIN_PROGRESS.CLEANUP) {
+    logger.info('cleanup', { from, to, sessionId });
+    await goNextState(NODE_MAINTAIN_PROGRESS.COMPLETE, true);
+    await sleep(8000);
+    await states.node.updateNodeInfo({ nextVersion: '', version: to, upgradeSessionId: '' });
+    try {
+      await states.node.exitMode(NODE_MODES.MAINTENANCE);
+    } catch (error) {
+      logger.error('Failed to exit maintenance mode', { error });
+    }
+  }
+  await lock.release();
+};
+
+const isBeingMaintained = async () => {
+  const info = await states.node.read();
+  if (!info.upgradeSessionId) {
+    return false;
+  }
+
+  const session = await states.session.read(info.upgradeSessionId);
+  if (!session) {
+    return false;
+  }
+
+  if (session.action === 'upgrade' && !info.nextVersion) {
+    return false;
+  }
+
+  return session;
+};
+
+const getCron = () => ({
+  name: 'check-update',
+  time: '0 0 8 * * *', // check every day
+  // time: '0 */5 * * * *', // check every 5 minutes
+  fn: async () => {
+    const info = await states.node.read();
+    if (!info.autoUpgrade) {
+      return;
+    }
+
+    checkNewVersion();
+  },
+  options: { runOnInit: false },
+});
+
+module.exports = { getCron, checkNewVersion, resumeMaintain, triggerMaintain, isBeingMaintained };

package/lib/validators/blocklet-extra.js

@@ -0,0 +1,24 @@
+const JOI = require('joi');
+const { didExtension } = require('@blocklet/meta/lib/extension');
+const { blockletController, createValidator } = require('./util');
+
+const Joi = JOI.extend(didExtension);
+
+const addMeta = Joi.object({
+  did: Joi.ref('meta.did'),
+  meta: Joi.object({
+    did: Joi.DID().required(),
+    name: Joi.string().required(),
+  }).required(),
+  controller: blockletController.optional(),
+}).required();
+
+const updateExpiredInfo = Joi.object({
+  did: Joi.DID().required(),
+  expiredAt: Joi.string().required(),
+});
+
+module.exports = {
+  validateAddMeta: createValidator(addMeta),
+  validateExpiredInfo: createValidator(updateExpiredInfo),
+};

package/lib/validators/blocklet.js

@@ -1,13 +1,4 @@
-const JOI = require('joi');
-const { didExtension } = require('@blocklet/meta/lib/extension');
-
-const Joi = JOI.extend(didExtension);
-
-const blockletController = Joi.object({
-  nftId: Joi.DID().required(),
-  nftOwner: Joi.DID().required(),
-  appMaxCount: Joi.number().required().min(1),
-}).options({ stripUnknown: true });
+const { blockletController } = require('./util');
 
 module.exports = {
   validateBlockletController: (entity) => blockletController.validateAsync(entity),

package/lib/validators/util.js

@@ -1,9 +1,25 @@
 const get = require('lodash/get');
+const JOI = require('joi');
+const { didExtension } = require('@blocklet/meta/lib/extension');
+
+const Joi = JOI.extend(didExtension);
+
+const getMultipleLangParams = (context) => ({
+  errors: {
+    language: get(context, 'query.locale', 'en'),
+  },
+});
+
+const blockletController = Joi.object({
+  nftId: Joi.DID().required(),
+  nftOwner: Joi.DID().required(),
+  appMaxCount: Joi.number().required().min(1),
+}).options({ stripUnknown: true });
+
+const createValidator = (schema) => (entity) => schema.validateAsync(entity);
 
 module.exports = {
-  getMultipleLangParams: (context) => ({
-    errors: {
-      language: get(context, 'query.locale', 'en'),
-    },
-  }),
+  createValidator,
+  getMultipleLangParams,
+  blockletController,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.56",
+  "version": "1.8.57",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,18 +19,18 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.8.56",
-    "@abtnode/certificate-manager": "1.8.56",
-    "@abtnode/constant": "1.8.56",
-    "@abtnode/cron": "1.8.56",
-    "@abtnode/db": "1.8.56",
-    "@abtnode/logger": "1.8.56",
-    "@abtnode/queue": "1.8.56",
-    "@abtnode/rbac": "1.8.56",
-    "@abtnode/router-provider": "1.8.56",
-    "@abtnode/static-server": "1.8.56",
-    "@abtnode/timemachine": "1.8.56",
-    "@abtnode/util": "1.8.56",
+    "@abtnode/auth": "1.8.57",
+    "@abtnode/certificate-manager": "1.8.57",
+    "@abtnode/constant": "1.8.57",
+    "@abtnode/cron": "1.8.57",
+    "@abtnode/db": "1.8.57",
+    "@abtnode/logger": "1.8.57",
+    "@abtnode/queue": "1.8.57",
+    "@abtnode/rbac": "1.8.57",
+    "@abtnode/router-provider": "1.8.57",
+    "@abtnode/static-server": "1.8.57",
+    "@abtnode/timemachine": "1.8.57",
+    "@abtnode/util": "1.8.57",
     "@arcblock/did": "1.18.34",
     "@arcblock/did-motif": "^1.1.10",
     "@arcblock/did-util": "1.18.34",
@@ -38,17 +38,19 @@
     "@arcblock/jwt": "^1.18.34",
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/vc": "1.18.34",
-    "@blocklet/constant": "1.8.56",
-    "@blocklet/meta": "1.8.56",
-    "@blocklet/sdk": "1.8.56",
+    "@blocklet/constant": "1.8.57",
+    "@blocklet/meta": "1.8.57",
+    "@blocklet/sdk": "1.8.57",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.34",
     "@ocap/util": "1.18.34",
     "@ocap/wallet": "1.18.34",
     "@slack/webhook": "^5.0.4",
+    "archiver": "^5.3.1",
     "axios": "^0.27.2",
     "axon": "^2.0.3",
     "chalk": "^4.1.2",
+    "dayjs": "^1.11.7",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.5.1",
     "escape-string-regexp": "^4.0.0",
@@ -83,5 +85,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "8c24c9d747e96e05510b9cbe863666960569fb46"
+  "gitHead": "2573eb9370c79853cba88cba418a964fb1cc8949"
 }

package/lib/util/upgrade.js

@@ -1,175 +0,0 @@
-/* eslint-disable no-param-reassign */
-const semver = require('semver');
-const sleep = require('@abtnode/util/lib/sleep');
-const { NODE_MODES, NODE_UPGRADE_PROGRESS, EVENTS } = require('@abtnode/constant');
-const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
-const Lock = require('@abtnode/util/lib/lock');
-const logger = require('@abtnode/logger')('@abtnode/core:upgrade');
-
-const states = require('../states');
-const doRpc = require('./rpc');
-
-const lock = new Lock('node-upgrade-lock');
-
-// eslint-disable-next-line no-unused-vars
-const checkNewVersion = async (params, context) => {
-  try {
-    const info = await states.node.read();
-
-    if (!process.env.ABT_NODE_PACKAGE_NAME) {
-      logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
-      return '';
-    }
-
-    const versions = await listNpmPackageVersion(process.env.ABT_NODE_PACKAGE_NAME);
-    if (Array.isArray(versions) && versions.length) {
-      const latestVersion = versions[0].version;
-      if (semver.gt(latestVersion, info.version)) {
-        // if (semver.gte(latestVersion, info.version)) {
-        logger.info('New version found for Blocklet Server', {
-          latestVersion,
-          currentVersion: info.version,
-          nextVersion: info.nextVersion,
-        });
-        await states.node.updateNodeInfo({ nextVersion: latestVersion });
-        await states.notification.create({
-          title: 'Blocklet Server upgrade available',
-          description: 'A new and improved version of blocklet server is now available',
-          entityType: 'node',
-          severity: 'info',
-          sticky: true,
-          action: '/settings/about',
-        });
-
-        return latestVersion;
-      }
-    }
-
-    return '';
-  } catch (err) {
-    logger.error('Failed to check new version for Blocklet Server', { error: err });
-  }
-
-  return '';
-};
-
-// eslint-disable-next-line no-unused-vars
-const startUpgrade = async (params, context) => {
-  const info = await states.node.read();
-
-  if (!info.nextVersion) {
-    throw new Error('Do nothing since there is no next version to upgrade');
-  }
-
-  const from = info.version;
-  const to = info.nextVersion;
-
-  // 0. ensure we have an upgrading session, we need a session to recover from crash
-  let sessionId = info.upgradeSessionId;
-  if (!sessionId) {
-    const result = await states.session.start({ from, to, stage: NODE_UPGRADE_PROGRESS.SETUP, startedAt: Date.now() });
-    sessionId = result.id;
-    logger.info('generate new session for upgrade', { from, to, sessionId });
-    await states.node.updateNodeInfo({ upgradeSessionId: sessionId });
-  }
-  const session = await states.session.read(sessionId);
-  if (!session) {
-    throw new Error(`Upgrade aborted due to invalid session: ${sessionId}`);
-  }
-
-  process.nextTick(async () => {
-    await doUpgrade(session);
-  });
-
-  return sessionId;
-};
-
-// TODO: error handling and rollback support
-const doUpgrade = async (session) => {
-  await lock.acquire();
-
-  const sessionId = session.id;
-  const info = await states.node.read();
-  const from = info.version;
-  const to = info.nextVersion;
-
-  const goNextState = async (stage) => {
-    session = await states.session.update(sessionId, { stage });
-    // Emit events so client will keep up
-    states.node.emit(EVENTS.NODE_UPGRADE_PROGRESS, session);
-  };
-
-  // 1. enter maintenance mode
-  if (session.stage === NODE_UPGRADE_PROGRESS.SETUP) {
-    logger.info('enter maintenance mode for upgrading', { from, to, sessionId });
-    await states.node.enterMode(NODE_MODES.MAINTENANCE);
-    await goNextState(NODE_UPGRADE_PROGRESS.INSTALLING);
-  }
-
-  // 2. install specified version
-  if (session.stage === NODE_UPGRADE_PROGRESS.INSTALLING) {
-    await doRpc({ command: 'install', version: to });
-    logger.info('new version installed for upgrading', { from, to, sessionId });
-    await goNextState(NODE_UPGRADE_PROGRESS.RESTARTING);
-  }
-
-  // 3. restarting update version in node config and state
-  if (session.stage === NODE_UPGRADE_PROGRESS.RESTARTING) {
-    logger.info('daemon restarted for upgrading', { from, to, sessionId });
-    await sleep(3000);
-    await goNextState(NODE_UPGRADE_PROGRESS.CLEANUP);
-    await sleep(3000);
-    await doRpc({ command: 'restart', dataDir: process.env.ABT_NODE_DATA_DIR });
-    await lock.release();
-    return; // we should abort here and resume after restart
-  }
-
-  // 4. reset node.nextVersion/upgradeSessionId and exit maintenance mode
-  if (session.stage === NODE_UPGRADE_PROGRESS.CLEANUP) {
-    logger.info('cleanup for upgrading', { from, to, sessionId });
-    await goNextState(NODE_UPGRADE_PROGRESS.COMPLETE);
-    await sleep(8000);
-    await states.node.updateNodeInfo({ nextVersion: '', version: to, upgradeSessionId: '' });
-    try {
-      await states.node.exitMode(NODE_MODES.MAINTENANCE);
-    } catch (error) {
-      logger.error('Failed to exit maintenance mode', { error });
-    }
-  }
-  await lock.release();
-};
-
-const isUpgrading = async () => {
-  const info = await states.node.read();
-  if (!info.nextVersion) {
-    return false;
-  }
-
-  if (!info.upgradeSessionId) {
-    return false;
-  }
-
-  const session = await states.session.read(info.upgradeSessionId);
-  if (!session) {
-    return false;
-  }
-
-  return session;
-};
-
-const getCron = () => ({
-  name: 'check-update',
-  time: '0 0 8 * * *', // check every day
-  // time: '0 */5 * * * *', // check every 5 minutes
-  fn: async () => {
-    const info = await states.node.read();
-    if (!info.autoUpgrade) {
-      return;
-    }
-
-    checkNewVersion();
-  },
-  options: { runOnInit: false },
-});
-
-module.exports = { getCron, checkNewVersion, doUpgrade, startUpgrade, isUpgrading };