@abtnode/core 1.6.17 → 1.6.18

package/lib/blocklet/hooks.js

@@ -1,68 +1,23 @@
-const childProcess = require('child_process');
 const get = require('lodash/get');
 const camelCase = require('lodash/camelCase');
+const runScript = require('@abtnode/util/lib/run-script');
 
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../package.json').name}:blocklet:hooks`);
 
 const { getSafeEnv } = require('../util');
 
-const runAsync = ({ appDir, env, hook, progress = false }) => {
-  const safeEnv = getSafeEnv(env);
-  const child = childProcess.exec(hook, {
-    cwd: appDir,
-    env: safeEnv,
-    stdio: 'inherit',
-  });
-
-  if (progress) {
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
-  }
-
-  return new Promise((resolve, reject) => {
-    const errorMessages = [];
-    let hasUnhandledRejection = false;
-
-    child.stderr.on('data', (err) => {
-      // Check if has unhandledRejection in childProcess
-      // https://stackoverflow.com/questions/32784649/gracefully-handle-errors-in-child-processes-in-nodejs
-      if (err.includes('UnhandledPromiseRejectionWarning')) {
-        hasUnhandledRejection = true;
-      }
-      errorMessages.push(err);
-    });
-
-    child.on('exit', (code) => {
-      if (errorMessages.length > 0) {
-        if (code !== 0 || hasUnhandledRejection) {
-          return reject(new Error(errorMessages.join('\r\n')));
-        }
-
-        if (!progress) {
-          errorMessages.forEach((message) => process.stderr.write(message));
-        }
-      }
-
-      return resolve();
-    });
-  });
-};
-
-/**
- * @param {*} args.did root blocklet did
- */
-const runUserHook = async (name, args) => {
-  const { appDir, hooks, env, exitOnError = true, progress = false, notification, did } = args;
-  const hook = get(hooks, `[${name}]`) || get(hooks, `[${camelCase(name)}]`);
+const runUserHook = async (appId, hookName, args) => {
+  const { appDir, hooks, env, exitOnError = true, silent = false, notification, did } = args;
+  const hook = get(hooks, `[${hookName}]`) || get(hooks, `[${camelCase(hookName)}]`);
 
   try {
     if (!hook) {
       return;
     }
 
-    logger.info(`run hook:${name}:`, { hook });
-    await runAsync({ appDir, env, hook, progress });
+    logger.info(`run hook:${hookName}:`, { hook });
+    await runScript(hook, [appId, hookName].join(':'), { cwd: appDir, env: getSafeEnv(env), silent });
   } catch (error) {
     logger.error(`run ${hook} error:`, { error });
 
@@ -77,33 +32,31 @@ const runUserHook = async (name, args) => {
     }
 
     if (exitOnError) {
-      throw new Error(`Run [${name}] failed: ${error.message}`);
+      throw new Error(`Run [${hookName}] failed: ${error.message}`);
     }
   }
 };
 
-const preDeploy = (...args) => runUserHook('pre-deploy', ...args);
-const preInstall = (...args) => runUserHook('pre-install', ...args);
-const postInstall = (...args) => runUserHook('post-install', ...args);
-
-const preStart = async (blocklet, option) => {
+const preDeploy = (appId, ...args) => runUserHook(appId, 'pre-deploy', ...args);
+const preInstall = (appId, ...args) => runUserHook(appId, 'pre-install', ...args);
+const postInstall = (appId, ...args) => runUserHook(appId, 'post-install', ...args);
+const preConfig = (appId, ...args) => runUserHook(appId, 'pre-config', ...args);
+const preStart = async (blocklet, options) => {
   // check required environments
   let environments = get(blocklet, 'meta.environments', []);
   if (!Array.isArray(environments)) {
     environments = [environments];
   }
 
-  const tmp = environments.filter((e) => e.required && option.env[e.name] === undefined).map((e) => e.name);
+  const tmp = environments.filter((e) => e.required && options.env[e.name] === undefined).map((e) => e.name);
   if (tmp.length > 0) {
     throw new Error(`Required environments is not set: ${tmp.join(',')}`);
   }
 
-  return runUserHook('pre-start', option);
+  return runUserHook(blocklet.env.appId, 'pre-start', options);
 };
 
-const preUninstall = (...args) => runUserHook('pre-uninstall', ...args);
-const preStop = (...args) => runUserHook('pre-stop', ...args);
-
-const preConfig = (...args) => runUserHook('pre-config', ...args);
+const preUninstall = (appId, ...args) => runUserHook(appId, 'pre-uninstall', ...args);
+const preStop = (appId, ...args) => runUserHook(appId, 'pre-stop', ...args);
 
 module.exports = { preDeploy, preInstall, postInstall, preStart, preUninstall, preStop, preConfig };

package/lib/blocklet/manager/disk.js

@@ -20,7 +20,6 @@ const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
-const { updateBlocklet: updateDidDocument } = require('@abtnode/util/lib/did-document');
 const { BLOCKLET_PURCHASE_NFT_TYPE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
@@ -31,7 +30,6 @@ const {
   hasRunnableComponent,
 } = require('@blocklet/meta/lib/util');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
-const { getBlockletInfo } = require('@blocklet/meta/lib');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
@@ -293,7 +291,6 @@ class BlockletManager extends BaseBlockletManager {
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
             env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did,
-            progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
         nodeEnvironments,
         nodeInfo: await states.node.read(),
@@ -344,7 +341,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async stop({ did, updateStatus = true }, context) {
+  async stop({ did, updateStatus = true, silent = false }, context) {
     logger.info('stop blocklet', { did });
 
     const blocklet = await this.ensureBlocklet(did);
@@ -360,7 +357,7 @@ class BlockletManager extends BaseBlockletManager {
 
     await stopBlockletProcess(blocklet, {
       preStop: (b) =>
-        hooks.preStop({
+        hooks.preStop(b.env.appId, {
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
@@ -368,7 +365,7 @@ class BlockletManager extends BaseBlockletManager {
           notification: states.notification,
           context,
           exitOnError: false,
-          progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
+          silent,
         }),
     });
 
@@ -436,7 +433,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await deleteBlockletProcess(blocklet, {
         preDelete: (b) =>
-          hooks.preUninstall({
+          hooks.preUninstall(b.env.appId, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
             env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
@@ -512,12 +509,14 @@ class BlockletManager extends BaseBlockletManager {
     return result;
   }
 
-  async detail({ did, attachRuntimeInfo = true }, context) {
+  async detail({ did, attachConfig = true, attachRuntimeInfo = true }, context) {
     if (!did) {
       throw new Error('did should not be empty');
     }
 
-    const nodeInfo = await states.node.read();
+    if (!attachConfig) {
+      return states.blocklet.getBlocklet(did);
+    }
 
     if (!attachRuntimeInfo) {
       try {
@@ -528,6 +527,8 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
+    const nodeInfo = await states.node.read();
+
     return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
@@ -624,14 +625,13 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // FIXME: we should also call preConfig for child blocklets
-    await hooks.preConfig({
+    await hooks.preConfig(blocklet.env.appId, {
       appDir: blocklet.env.appDir,
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
       exitOnError: true,
       env: { ...getRuntimeEnvironments(blocklet, nodeEnvironments), ...blocklet.configObj },
       did,
       context,
-      progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
     });
 
     // update db
@@ -887,6 +887,11 @@ class BlockletManager extends BaseBlockletManager {
   // ============================================================================================
   // Internal API that are used by public APIs and called from CLI
   // ============================================================================================
+
+  /**
+   * After the dev function finished, the caller should send a BlockletEvents.deployed event to the daemon
+   * @returns {Object} blocklet
+   */
   async dev(folder) {
     logger.info('dev blocklet', { folder });
 
@@ -919,11 +924,13 @@ class BlockletManager extends BaseBlockletManager {
       await this.deleteProcess({ did });
       logger.info('delete blocklet precess for dev', { did, version });
     } catch (err) {
-      logger.error('failed to delete blocklet process for dev', { error: err });
+      if (process.env.NODE_ENV !== 'development') {
+        logger.error('failed to delete blocklet process for dev', { error: err });
+      }
     }
 
     const children = await this._getChildren(meta);
-    const blocklet = await states.blocklet.addBlocklet({
+    const added = await states.blocklet.addBlocklet({
       did,
       meta,
       source: BlockletSource.local,
@@ -934,15 +941,16 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('add blocklet for dev', { did, version, meta });
 
     const oldBlocklet = { children: children.filter((x) => x.dynamic) }; // let downloader skip re-downloading dynamic blocklet
-    await this._downloadBlocklet(blocklet, oldBlocklet);
+    await this._downloadBlocklet(added, oldBlocklet);
     await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
     // Add environments
     await this._setConfigs(did);
     await this.updateBlockletEnvironment(did);
 
-    this.emit(BlockletEvents.deployed, { blocklet, context: {} });
-    return this.ensureBlocklet(did);
+    const blocklet = await this.ensureBlocklet(did);
+
+    return blocklet;
   }
 
   async ensureBlocklet(did) {
@@ -1705,19 +1713,6 @@ class BlockletManager extends BaseBlockletManager {
     );
   }
 
-  async getStatus(did) {
-    if (!did) {
-      throw new Error('did is required');
-    }
-
-    const blocklet = await states.blocklet.getBlocklet(did);
-    if (!blocklet) {
-      return null;
-    }
-
-    return { name: blocklet.meta.name, did: blocklet.meta.did, status: blocklet.status };
-  }
-
   async prune() {
     const blocklets = await states.blocklet.getBlocklets();
     const settings = await states.blockletExtras.listSettings();
@@ -2126,7 +2121,7 @@ class BlockletManager extends BaseBlockletManager {
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall({
+        hooks.preInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2142,7 +2137,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // post install
       const postInstall = (b) =>
-        hooks.postInstall({
+        hooks.postInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
@@ -2155,17 +2150,6 @@ class BlockletManager extends BaseBlockletManager {
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
-      if (process.env.NODE_ENV !== 'test') {
-        const nodeInfo = await states.node.read();
-        const blockletInfo = getBlockletInfo(blocklet, nodeInfo.sk);
-        const updateDidDnsResult = await updateDidDocument({
-          wallet: blockletInfo.wallet,
-          domain: nodeInfo.didDomain,
-          nodeDid: nodeInfo.did,
-          didRegistryUrl: nodeInfo.didRegistry,
-        });
-        logger.info('updated did document', { updateDidDnsResult, blockletId: blocklet.meta.did });
-      }
 
       this.emit(BlockletEvents.installed, { blocklet, context });
 
@@ -2226,7 +2210,7 @@ class BlockletManager extends BaseBlockletManager {
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall({
+        hooks.preInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2242,7 +2226,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // post install
       const postInstall = (b) =>
-        hooks.postInstall({
+        hooks.postInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
@@ -2258,10 +2242,10 @@ class BlockletManager extends BaseBlockletManager {
         if (b.meta.did === did) {
           return runMigrationScripts({
             blocklet: b,
+            appDir: b.env.appDir,
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             oldVersion,
             newVersion: version,
-            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
-            appDir: b.env.appDir,
             did: b.meta.did,
             notification: states.notification,
             context,

package/lib/blocklet/migration.js

@@ -1,67 +1,25 @@
 /* eslint-disable no-await-in-loop */
-const childProcess = require('child_process');
 const fs = require('fs-extra');
 const path = require('path');
 const semver = require('semver');
+const runScript = require('@abtnode/util/lib/run-script');
 
 const { getMigrationScripts: getScripts } = require('../migrations');
 const { getSafeEnv } = require('../util');
 const { name } = require('../../package.json');
 const logger = require('@abtnode/logger')(`${name}:blocklet:migration`); // eslint-disable-line
 
-const _runScript = ({ appDir, env, migrationScript, progress = false }) => {
-  const safeEnv = getSafeEnv(env);
-
-  const child = childProcess.exec(`node ${migrationScript}`, {
-    cwd: appDir,
-    env: safeEnv,
-    stdio: 'inherit',
-  });
-  let hasUnhandledRejection = false;
-
-  if (progress) {
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
-  }
-
-  return new Promise((resolve, reject) => {
-    const errorMessages = [];
-
-    child.stderr.on('data', (err) => {
-      // Check if has unhandledRejection in childProcess
-      // https://stackoverflow.com/questions/32784649/gracefully-handle-errors-in-child-processes-in-nodejs
-      if (err.includes('UnhandledPromiseRejectionWarning')) {
-        hasUnhandledRejection = true;
-      }
-      errorMessages.push(err);
-    });
-
-    child.on('exit', (code) => {
-      if (errorMessages.length > 0) {
-        if (code !== 0 || hasUnhandledRejection) {
-          return reject(new Error(errorMessages.join('\r\n')));
-        }
-
-        if (!progress) {
-          errorMessages.forEach((message) => process.stderr.write(message));
-        }
-      }
-
-      return resolve();
-    });
-  });
-};
-
 async function runScripts({
+  blocklet,
+  appDir,
+  env,
+  oldVersion,
   dbDir,
   backupDir,
   scriptsDir,
   printInfo,
   printSuccess,
   printError,
-  appDir,
-  env,
-  oldVersion,
 }) {
   let scripts = [];
   try {
@@ -90,7 +48,11 @@ async function runScripts({
     const { script: scriptPath } = pendingScripts[i];
     try {
       printInfo(`Migration script started: ${scriptPath}`);
-      await _runScript({ appDir, env, migrationScript: path.join(scriptsDir, scriptPath) });
+      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.appId, 'migration'].join(':'), {
+        cwd: appDir,
+        env: getSafeEnv(env),
+        silent: false,
+      });
       printInfo(`Migration script executed: ${scriptPath}`);
     } catch (migrationErr) {
       printError(`Failed to execute migration script: ${scriptPath}, error: ${migrationErr.message}`);
@@ -123,6 +85,7 @@ async function doRestore({ dbDir, backupDir, printInfo, printSuccess }) {
 }
 
 module.exports = async ({
+  blocklet,
   appDir,
   env,
   oldVersion,
@@ -142,15 +105,16 @@ module.exports = async ({
   fs.ensureDirSync(backupDir);
 
   await runScripts({
+    blocklet,
+    appDir,
+    env,
+    oldVersion,
+    newVersion,
     dbDir,
     backupDir,
     scriptsDir,
     printError,
     printInfo,
     printSuccess,
-    appDir,
-    env,
-    oldVersion,
-    newVersion,
   });
 };

package/lib/index.js

@@ -208,7 +208,6 @@ function ABTNode(options) {
     upgradeBlocklet: blockletManager.upgrade.bind(blockletManager),
     configBlocklet: blockletManager.config.bind(blockletManager),
     devBlocklet: blockletManager.dev.bind(blockletManager),
-    getBlockletStatus: blockletManager.getStatus.bind(blockletManager),
     checkChildBlockletsForUpdates: blockletManager.checkChildrenForUpdates.bind(blockletManager),
     updateChildBlocklets: blockletManager.updateChildren.bind(blockletManager),
     getLatestBlockletVersion: blockletManager.getLatestBlockletVersion.bind(blockletManager),

package/lib/router/helper.js

@@ -660,7 +660,9 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const dashboardDomain = get(info, 'routing.dashboardDomain', '');
     const didDomain = `${info.did.toLowerCase()}.${info.didDomain}`;
-    const dashboardAliasDomains = [dashboardDomain, didDomain]
+    let dashboardAliasDomains = [dashboardDomain, didDomain];
+
+    dashboardAliasDomains = dashboardAliasDomains
       .filter((item) => item && !isExistsInAlias(item))
       .map((item) => ({ value: item, isProtected: true }));
 
@@ -747,17 +749,15 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     const existSite = await states.site.findOne({ domain: domainGroup });
     if (!existSite) {
       const ipEchoDnsDomain = getIpDnsDomainForBlocklet(blocklet, webInterface, nodeInfo.did);
-      const appIdEnv = blocklet.environments.find((e) => e.key === 'BLOCKLET_APP_ID');
       const domainAliases = [{ value: ipEchoDnsDomain, isProtected: true }];
 
       const didDomain = getDidDomainForBlocklet({
-        appId: appIdEnv.value,
+        name: blocklet.meta.name,
+        daemonDid: nodeInfo.did,
         didDomain: nodeInfo.didDomain,
       });
 
-      if (blocklet.mode !== 'development') {
-        domainAliases.push({ value: didDomain, isProtected: true });
-      }
+      domainAliases.push({ value: didDomain, isProtected: true });
 
       await routerManager.addRoutingSite(
         {

package/lib/util/blocklet.js

@@ -252,7 +252,7 @@ const getRootSystemEnvironments = (blocklet, nodeInfo) => {
   const appDescription = description || result.description;
 
   // FIXME: we should use https here when possible, eg, when did-gateway is available
-  const appUrl = `http://${getDidDomainForBlocklet({ appId, didDomain: nodeInfo.didDomain })}`;
+  const appUrl = `http://${getDidDomainForBlocklet({ name, daemonDid: nodeInfo.did, didDomain: nodeInfo.didDomain })}`;
 
   return {
     BLOCKLET_DID: did,

package/lib/util/get-domain-for-blocklet.js

@@ -16,8 +16,8 @@ const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
   }${iName}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DNS_DOMAIN_SUFFIX}`;
 };
 
-const getDidDomainForBlocklet = ({ appId, didDomain }) => {
-  return `${appId.toLowerCase()}.${didDomain}`;
+const getDidDomainForBlocklet = ({ name, daemonDid, didDomain }) => {
+  return `${formatName(name)}-${daemonDid.toLowerCase()}.${didDomain}`;
 };
 
 module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.17",
+  "version": "1.6.18",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,22 +19,22 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/certificate-manager": "1.6.17",
-    "@abtnode/constant": "1.6.17",
-    "@abtnode/cron": "1.6.17",
-    "@abtnode/db": "1.6.17",
-    "@abtnode/logger": "1.6.17",
-    "@abtnode/queue": "1.6.17",
-    "@abtnode/rbac": "1.6.17",
-    "@abtnode/router-provider": "1.6.17",
-    "@abtnode/static-server": "1.6.17",
-    "@abtnode/timemachine": "1.6.17",
-    "@abtnode/util": "1.6.17",
+    "@abtnode/certificate-manager": "1.6.18",
+    "@abtnode/constant": "1.6.18",
+    "@abtnode/cron": "1.6.18",
+    "@abtnode/db": "1.6.18",
+    "@abtnode/logger": "1.6.18",
+    "@abtnode/queue": "1.6.18",
+    "@abtnode/rbac": "1.6.18",
+    "@abtnode/router-provider": "1.6.18",
+    "@abtnode/static-server": "1.6.18",
+    "@abtnode/timemachine": "1.6.18",
+    "@abtnode/util": "1.6.18",
     "@arcblock/did": "^1.14.8",
     "@arcblock/event-hub": "1.14.8",
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/vc": "^1.14.8",
-    "@blocklet/meta": "1.6.17",
+    "@blocklet/meta": "1.6.18",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
@@ -75,5 +75,5 @@
     "express": "^4.17.1",
     "jest": "^27.4.5"
   },
-  "gitHead": "d567a622a779eba43c95eaeb4633cb2b276bb7b9"
+  "gitHead": "2f02f166869d8ebedc0466068f6ed90ab3e07b87"
 }