@abtnode/core 1.6.15 → 1.6.19

package/lib/api/node.js

@@ -93,7 +93,7 @@ class NodeAPI {
   async updateNodeInfo(entity = {}, context) {
     await validateNodeInfo(entity, context);
 
-    if (entity.autoUpgrade) {
+    if (entity.autoUpgrade && process.env.NODE_ENV !== 'development') {
       try {
         canPackageReadWrite(process.env.ABT_NODE_BINARY_NAME, process.env.ABT_NODE_PACKAGE_NAME);
       } catch (err) {

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 };