@blocklet/cli 1.16.33 → 1.16.34-beta-20241120-080738-bbbe036c

package/lib/manager/process.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const pm2 = require('@abtnode/util/lib/async-pm2');
+
+const { PROCESS_NAME_DAEMON } = require('@abtnode/constant');
+
+const getPm2ProcessInfo = (name) =>
+  new Promise((resolve, reject) => {
+    pm2.describe(name, (err, [info]) => {
+      if (err) {
+        return reject(err);
+      }
+
+      return resolve(info);
+    });
+  });
+
+const isRunning = async (name) => {
+  const info = await getPm2ProcessInfo(name);
+  return !!info;
+};
+
+const checkRunning = async () => {
+  const isDaemonRunning = await isRunning(PROCESS_NAME_DAEMON);
+  return isDaemonRunning === true;
+};
+
+const getRunningConfigFile = async () => {
+  if (!(await isRunning(PROCESS_NAME_DAEMON))) {
+    return '';
+  }
+
+  const instanceInfo = await getPm2ProcessInfo(PROCESS_NAME_DAEMON);
+  const { ABT_NODE_CONFIG_FILE: runningInstanceConfigFile = '' } = instanceInfo.pm2_env.env;
+
+  return runningInstanceConfigFile;
+};
+
+const getRunningConfigDataDir = async () => {
+  const configFile = await getRunningConfigFile();
+  if (configFile) {
+    return path.dirname(configFile);
+  }
+
+  return '';
+};
+
+module.exports = { checkRunning, getPm2ProcessInfo, getRunningConfigFile, getRunningConfigDataDir };

package/lib/node.js

@@ -0,0 +1,214 @@
+const fs = require('fs');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const ABTNode = require('@abtnode/core');
+const security = require('@abtnode/util/lib/security');
+const { WsClient } = require('@arcblock/ws');
+const { isFromPublicKey } = require('@arcblock/did');
+const { getBaseUrls } = require('@abtnode/core/lib/util');
+
+const debug = require('./debug')('node');
+const { version } = require('../package.json');
+
+const util = require('./util');
+const {
+  getDataDirectoryByConfigFile,
+  getConfigFile,
+  joinKFile,
+  getConfigDir,
+  verifyDataDirectory,
+} = require('./manager');
+
+const { print, printError, printInfo } = util;
+
+const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
+
+const getOwner = (info) => {
+  if (info && info.pk && info.did && isFromPublicKey(info.did, info.pk)) {
+    return info;
+  }
+
+  return undefined;
+};
+
+const printConfigError = () => {
+  printError('Cannot find config file for Blocklet Server');
+  printInfo(`Please initialize a configuration directory first: run ${chalk.cyan('blocklet server init')}`);
+  print();
+};
+
+let instance = null;
+let client = null;
+
+const readNodeConfig = async (dir) => {
+  const configDir = await getConfigDir(dir);
+  if (fs.existsSync(configDir)) {
+    try {
+      verifyDataDirectory(configDir);
+    } catch (error) {
+      debug('validate data directory failed:', error);
+      printError('Validate data directory failed:', error.message);
+      process.exit(1);
+    }
+  } else {
+    printConfigError();
+    process.exit(1); // TODO: 太讨厌这种提前 exit 的函数了，非常不好调试, polunzh
+  }
+
+  const configFile = await getConfigFile(dir);
+
+  let config = {};
+  try {
+    config = yaml.load(fs.readFileSync(configFile).toString(), { json: true });
+    const ukFile = joinKFile(configDir);
+    if (fs.existsSync(ukFile) && isHex(config.node.sk) === false) {
+      config.node.sk = security.decrypt(config.node.sk, config.node.did, fs.readFileSync(ukFile));
+    }
+  } catch (err) {
+    debug(err);
+    printError('Blocklet Server config parse failed', err.message);
+    process.exit(1);
+  }
+
+  return { config, configFile, dataDir: getDataDirectoryByConfigFile(configFile) };
+};
+
+const readNodeConfigWithValidate = async (dir) => {
+  const { config, configFile, dataDir } = await readNodeConfig(dir);
+
+  // validate node config
+  const wallet = util.getWallet(config.node.sk);
+  if (wallet.address !== config.node.did) {
+    printError('config.node.sk and config.node.did does not match');
+    process.exit(1);
+  }
+
+  if (!config.node.port) {
+    printError('config.node.port must be specified');
+    process.exit(1);
+  }
+
+  printInfo('Server DID', chalk.cyan(config.node.did));
+
+  return { config, configFile, dataDir };
+};
+
+async function getNode({ dir = process.cwd() } = {}) {
+  const { config, configFile, dataDir } = await readNodeConfigWithValidate(dir);
+
+  util.ensurePermission(dataDir);
+
+  printInfo('Server config from', chalk.cyan(configFile));
+
+  const wallet = util.getWallet(config.node.sk);
+  const node = ABTNode({
+    version,
+    nodeSk: wallet.secretKey,
+    nodePk: wallet.publicKey,
+    nodeDid: wallet.address,
+    port: config.node.port,
+    dataDir,
+    nodeOwner: getOwner(config.node.owner),
+    name: config.node.name,
+    description: config.node.description,
+    blockletPort: config.blocklet.port,
+    routing: config.node.routing,
+    docker: config.node.docker,
+    mode: config.node.mode,
+    runtimeConfig: config.node.runtimeConfig,
+    ownerNft: config.node.ownerNft || { holder: '', issuer: '' },
+    launcher: config.node.launcher,
+    didRegistry: config.node.didRegistry,
+    didDomain: config.node.didDomain,
+    slpDomain: config.node.slpDomain,
+    enablePassportIssuance: config.node.enablePassportIssuance,
+    trustedPassports: config.node.trustedPassports,
+    webWalletUrl: config.node.webWalletUrl,
+  });
+
+  return {
+    node,
+    config,
+    dataDir,
+    configFile,
+    wallet,
+    getBaseUrls: (ips) => getBaseUrls(node, ips),
+    publishEvent: (event, data) => publishEvent(node, event, data),
+    getWsClient: () => getWsClient(node),
+  };
+}
+
+async function getWsClient(node) {
+  if (!client) {
+    const info = await node.getNodeInfo();
+    const endpoint = `ws://127.0.0.1:${info.port}`;
+    const wallet = util.getWallet(info.sk);
+    const timestamp = Date.now().toString();
+
+    client = new WsClient(endpoint, {
+      silent: true,
+      params: () => ({
+        token: wallet.sign(timestamp),
+        timestamp,
+      }),
+    });
+
+    process.on('exit', () => {
+      client.disconnect();
+    });
+  }
+
+  if (client.isConnected()) {
+    return client;
+  }
+
+  return new Promise((resolve, reject) => {
+    client.onOpen(() => {
+      resolve(client);
+    });
+
+    client.onError((err) => {
+      reject(new Error(`Failed to connect to daemon socket server: ${err.message}`));
+    });
+
+    client.connect();
+  });
+}
+
+function publishEvent(node, event, data) {
+  return new Promise((resolve, reject) => {
+    getWsClient(node)
+      .then((c) => {
+        const channel = c.channel('cli');
+        channel
+          .join()
+          .receive('ok', () => {
+            channel.push(event, data);
+            channel.leave();
+            resolve(true);
+          })
+          .receive('error', (err) => {
+            reject(new Error(`join channel error: ${err.message}`));
+          })
+          .receive('timeout', () => {
+            reject(new Error('join channel timeout: cli'));
+          });
+      })
+      .catch((err) => reject(err));
+  });
+}
+
+module.exports = {
+  getNode: async (...args) => {
+    if (instance) {
+      return instance;
+    }
+
+    instance = await getNode(...args);
+    return instance;
+  },
+  readNodeConfig,
+  readNodeConfigWithValidate,
+  publishEvent,
+  getWsClient,
+};

package/lib/port.js

@@ -0,0 +1,19 @@
+const {
+  PROCESS_NAME_PROXY,
+  PROCESS_NAME_UPDATER,
+  PROCESS_NAME_SERVICE,
+  PROCESS_NAME_EVENT_HUB,
+} = require('@abtnode/constant');
+
+const ports = {
+  [PROCESS_NAME_PROXY]: 40404,
+  [PROCESS_NAME_UPDATER]: 40405,
+  [PROCESS_NAME_SERVICE]: 40406,
+  [PROCESS_NAME_EVENT_HUB]: 40407,
+};
+
+const getInternalPort = (processName) => {
+  return ports[processName];
+};
+
+module.exports = { getInternalPort };

package/lib/postinstall.js

@@ -0,0 +1,3 @@
+const { ensureNewInstalled } = require('./arcblock');
+
+ensureNewInstalled();

package/lib/process/daemon.js

@@ -0,0 +1,196 @@
+/* eslint-disable no-console */
+/* eslint-disable no-await-in-loop */
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
+const fs = require('fs');
+const path = require('path');
+
+process.env.ABT_NODE_LOG_NAME = 'daemon';
+process.env.ABT_NODE_LOG_DIR = path.join(process.env.ABT_NODE_DATA_DIR, 'logs', '_abtnode'); // enable log
+
+const runningBefore = !!process.env.BLOCKLET_SERVER_RUNNING_BEFORE;
+
+const logger = require('@abtnode/logger')('daemon');
+const ABTNode = require('@abtnode/core');
+const AsyncQueue = require('async/queue');
+const formatContext = require('@abtnode/util/lib/format-context');
+const getNodeWallet = require('@abtnode/util/lib/get-app-wallet');
+const { BlockletStatus } = require('@blocklet/constant');
+const { getBlockletEngine } = require('@blocklet/meta/lib/engine');
+const { findComponentV2, forEachComponentV2, hasStartEngine, getDisplayName } = require('@blocklet/meta/lib/util');
+const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
+const getPm2ProcessInfo = require('@abtnode/util/lib/get-pm2-process-info');
+const { SERVER_STATUS } = require('@abtnode/constant');
+
+const createServer = require('@abtnode/webapp/blocklet'); // eslint-disable-line
+
+const wallet = getNodeWallet(process.env.ABT_NODE_SK);
+const dataDir = process.env.ABT_NODE_DATA_DIR;
+
+const node = ABTNode({
+  nodeSk: wallet.secretKey,
+  nodePk: wallet.publicKey,
+  nodeDid: wallet.address,
+  port: process.env.ABT_NODE_PORT,
+  dataDir,
+  blockletPort: process.env.ABT_NODE_BLOCKLET_PORT,
+  daemon: true,
+});
+
+node.collectorPath = path.dirname(require.resolve('@blocklet/form-collector'));
+
+const createAuditLog = (action, args, result) => {
+  return node
+    .createAuditLog(
+      {
+        action,
+        args,
+        context: formatContext({
+          user: { fullName: 'CLI', role: 'admin', did: wallet.address },
+          headers: { 'user-agent': 'CLI' },
+        }),
+        result,
+      },
+      node
+    )
+    .catch(console.error);
+};
+
+const getComponentDids = async ({ app }) => {
+  const processNotRunnings = [];
+  await forEachComponentV2(app, async (component) => {
+    if (component.status !== BlockletStatus.running) {
+      return;
+    }
+
+    if (!hasStartEngine(component.meta)) {
+      return;
+    }
+
+    if (getBlockletEngine(component.meta)?.interpreter === 'blocklet') {
+      return;
+    }
+
+    const processId = getComponentProcessId(component, [app]);
+    try {
+      const info = await getPm2ProcessInfo(processId);
+      if (info.pm2_env.status !== 'online') {
+        // process not running
+        processNotRunnings.push(component.meta.did);
+      }
+    } catch {
+      // probably process not exists
+      processNotRunnings.push(component.meta.did);
+    }
+  });
+
+  return processNotRunnings;
+};
+
+const restartRunningComponent = async () => {
+  const queue = AsyncQueue(async (app, next) => {
+    logger.info(`Restarting app ${getDisplayName(app)}...`);
+    const componentDids = await getComponentDids({ app });
+
+    if (!componentDids.length) {
+      logger.info(`> No component need to restart for app ${getDisplayName(app)}`);
+      next();
+      return;
+    }
+
+    try {
+      const result = await node.startBlocklet({ did: app.meta.did, checkHealthImmediately: true, componentDids }, {});
+      logger.info(`> Restarted app ${getDisplayName(app)} / [${componentDids.join(',')}]`);
+      await createAuditLog('startBlocklet', { did: app.meta.did, reason: 'on server restart' }, result);
+    } catch (err) {
+      logger.error(`> Restarted app ${getDisplayName(app)} / [${componentDids.join(',')}] failed`, err);
+    }
+
+    next();
+  }, 1);
+
+  const apps = await node.getBlocklets({ includeRuntimeInfo: false });
+  const running = apps.filter((app) =>
+    findComponentV2(app, (component) => component.status === BlockletStatus.running)
+  );
+  if (running.length === 0) {
+    return;
+  }
+
+  running.forEach((app) => queue.push(app));
+  await queue.drain();
+};
+
+const syncComponentStatus = async () => {
+  const apps = await node.getBlocklets({ includeRuntimeInfo: false });
+  for (let i = 0; i < apps.length; i++) {
+    const app = apps[i];
+    try {
+      await node.syncBlockletStatus(app.meta.did, { forceSync: true });
+    } catch (err) {
+      logger.error(`Blocklet ${getDisplayName(app)} status sync failed: ${err.message}`);
+    }
+  }
+};
+
+logger.info('Waiting for Blocklet Server Daemon instance created');
+node.onReady(async () => {
+  logger.info('Blocklet Server Daemon instance was created');
+  const info = await node.getNodeInfo();
+
+  await node.handleRouting(info);
+  logger.info('Service gateway was restarted');
+
+  const server = createServer(node);
+  server.listen(process.env.ABT_NODE_PORT, async (err) => {
+    if (err) throw err;
+    console.info(`> Blocklet Server Daemon ready on ${process.env.ABT_NODE_PORT}`);
+
+    // Should resume upgrading if we are in process
+    const session = await node.isBeingMaintained();
+    if (session) {
+      console.info('> Resume maintain', session);
+      await node.resumeMaintain(session);
+    }
+
+    try {
+      await node.cleanupDirtyMaintainState();
+    } catch (e) {
+      console.error('Blocklet Server failed to cleanup dirty maintain state', e);
+    }
+
+    try {
+      const initialized = await node.isInitialized();
+      if (initialized) {
+        // 无论之前是否 crash, 当启动 server (非热重启) 时，永远重启之前运行中的组件
+        await node.updateNodeStatus(SERVER_STATUS.RUNNING);
+        if (!runningBefore) {
+          await restartRunningComponent();
+        } else {
+          logger.info('> Blocklet Server is restarted from running before');
+        }
+
+        await syncComponentStatus();
+      }
+    } catch (e) {
+      console.error('> Blocklet Server failed to restart running blocklets', e);
+    }
+
+    try {
+      if (dataDir && fs.existsSync(path.join(dataDir, 'start.lock')) === false) {
+        await node.createNotification({
+          title: 'Blocklet Server Crashed',
+          description: `Seems like blocklet server (did: ${info.did}, pid: ${process.pid}) just recovered from a crash, please check logs for more detail.`,
+          entityType: 'node',
+          severity: 'error',
+          sticky: true,
+          action: '/logs/abtnode',
+        });
+      }
+    } catch {
+      // Do nothing
+    }
+  });
+});

package/lib/process/service.js

@@ -0,0 +1,86 @@
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
+const fs = require('fs');
+const path = require('path');
+
+const { BlockletStatus, BlockletInternalEvents } = require('@blocklet/constant');
+const { filterComponentsV2 } = require('@blocklet/meta/lib/util');
+
+process.env.ABT_NODE_LOG_NAME = 'service';
+process.env.ABT_NODE_LOG_DIR = path.join(process.env.ABT_NODE_DATA_DIR, 'logs', '_abtnode'); // enable log
+
+const ABTNode = require('@abtnode/core');
+const getNodeWallet = require('@abtnode/util/lib/get-app-wallet');
+
+const createServer = require('@abtnode/blocklet-services');
+
+const { version } = require('../../package.json');
+
+const wallet = getNodeWallet(process.env.ABT_NODE_SK);
+const port = Number(process.env.ABT_NODE_SERVICE_PORT);
+const dataDir = process.env.ABT_NODE_DATA_DIR;
+
+const node = ABTNode({
+  nodeSk: wallet.secretKey,
+  nodePk: wallet.publicKey,
+  nodeDid: wallet.address,
+  port: process.env.ABT_NODE_PORT,
+  dataDir,
+  blockletPort: process.env.ABT_NODE_BLOCKLET_PORT,
+  service: true,
+});
+
+const notifyServerVersionToApps = async (server) => {
+  try {
+    const apps = await node.getBlocklets({ includeRuntimeInfo: false });
+    const runningApps = apps.filter(
+      (app) => filterComponentsV2(app, (x) => x.status === BlockletStatus.running).length
+    );
+    await Promise.all(
+      runningApps.map(async (app) => {
+        await server.sendToAppComponents({
+          appDid: app.appDid,
+          event: BlockletInternalEvents.appConfigChanged,
+          data: { configs: [{ key: 'ABT_NODE_VERSION', value: version }] },
+        });
+        await node.syncAppConfig(app, { serverVersion: version });
+      })
+    );
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+node.onReady(() => {
+  const server = createServer(node);
+
+  server.listen(port, '127.0.0.1', async (err) => {
+    if (err) throw err;
+    // eslint-disable-next-line
+    console.log(`> Blocklet Service ready on ${port}`);
+
+    try {
+      if (dataDir && fs.existsSync(path.join(dataDir, 'start.lock')) === false) {
+        await node.createNotification({
+          title: 'Blocklet Service Crashed',
+          description: `Seems like blocklet service (pid: ${process.pid}) just recovered from a crash, please check logs for more detail.`,
+          entityType: 'node',
+          severity: 'error',
+          sticky: true,
+          action: '/logs/abtnode',
+        });
+      }
+    } catch {
+      // Do nothing
+    }
+
+    setTimeout(() => {
+      // Let first worker process do something as master
+      if (process.env.NODE_APP_INSTANCE === '0') {
+        notifyServerVersionToApps(server);
+      }
+    }, 1000 * 30);
+  });
+});

package/lib/ui.js

@@ -0,0 +1,137 @@
+const ora = require('ora');
+const util = require('util');
+const chalk = require('chalk');
+const progress = require('cli-progress');
+const symbols = require('log-symbols');
+
+// https://github.com/sindresorhus/cli-spinners/blob/master/spinners.json
+const spinners = [
+  'dots',
+  'dots2',
+  'dots3',
+  'dots4',
+  'dots5',
+  'dots6',
+  'dots7',
+  'dots8',
+  'dots9',
+  'dots10',
+  'dots11',
+  'dots12',
+  'line',
+  'line2',
+  'pipe',
+  'simpleDots',
+  'simpleDotsScrolling',
+  'star',
+  'star2',
+  'flip',
+  'hamburger',
+  'growVertical',
+  'growHorizontal',
+  'balloon',
+  'balloon2',
+  'noise',
+  'bounce',
+  'boxBounce',
+  'boxBounce2',
+  'triangle',
+  'arc',
+  'circle',
+  'squareCorners',
+  'circleQuarters',
+  'circleHalves',
+  'squish',
+  'toggle',
+  'toggle2',
+  'toggle3',
+  'toggle4',
+  'toggle5',
+  'toggle6',
+  'toggle7',
+  'toggle8',
+  'toggle9',
+  'toggle10',
+  'toggle11',
+  'toggle12',
+  'toggle13',
+  'arrow',
+  'arrow2',
+  'arrow3',
+  'bouncingBar',
+  'bouncingBall',
+  'smiley',
+  'monkey',
+  'hearts',
+  'clock',
+  'earth',
+  'moon',
+  'runner',
+  'pong',
+  'shark',
+  'dqpb',
+  'weather',
+  'christmas',
+  'grenade',
+  'point',
+  'layer',
+];
+
+const getSpinner = (opts) => {
+  const random = Math.floor(Math.random() * spinners.length);
+  const spinner = ora(Object.assign({ spinner: spinners[random] }, opts || {}));
+  if (typeof opts === 'string') {
+    spinner.text = opts;
+  }
+
+  return spinner;
+};
+
+const wrapSpinner = async (
+  // eslint-disable-next-line default-param-last
+  message = '',
+  func,
+  { throwOnError = true, printErrorFn = console.error, ref = {} } = {}
+) => {
+  const spinner = getSpinner(message);
+  ref.spinner = spinner;
+  const startTime = Date.now();
+  spinner.start();
+  try {
+    const result = await func();
+    spinner.succeed(`${message} Done in ${chalk.cyan((Date.now() - startTime) / 1000)}s`);
+    return result;
+  } catch (err) {
+    spinner.fail(`${message} Fail after ${chalk.cyan((Date.now() - startTime) / 1000)}s`);
+
+    if (typeof printErrorFn === 'function') {
+      printErrorFn(err.message);
+    }
+
+    if (throwOnError) {
+      throw err;
+    }
+
+    return err;
+  }
+};
+
+module.exports = {
+  symbols,
+  pretty: (data, options) => {
+    if (data && typeof data === 'object') {
+      return `\n${JSON.stringify(data, null, 2)}\n`;
+    }
+
+    return util.inspect(data, Object.assign({ depth: 8, colors: true, compact: false }, options));
+  },
+  getProgress: ({ title, unit = 'MB' }) =>
+    new progress.Bar({
+      format: `${title} |${chalk.cyan('{bar}')} {percentage}% || {value}/{total} ${unit}`,
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true,
+    }),
+  getSpinner,
+  wrapSpinner,
+};