@abtnode/core 1.15.17 → 1.16.0-beta-b16cb035

package/lib/blocklet/extras.js

@@ -1,17 +1,23 @@
 const uniqBy = require('lodash/uniqBy');
-const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/meta/lib/constants');
+const cloneDeep = require('lodash/cloneDeep');
+const security = require('@abtnode/util/lib/security');
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
 
-const mergeConfigs = (oldConfigs, newConfigs = []) => {
-  const metaConfigs = (oldConfigs || []).filter((x) => !x.custom);
-  const customConfigs = (oldConfigs || []).filter((x) => x.custom);
-
-  const metaConfigsToKeep = metaConfigs.filter((x) => newConfigs.find((n) => n.key === x.key || n.name === x.key));
+const removeDeletedMetaConfigs = (oldConfigs, newConfigs) =>
+  oldConfigs.filter((old) => newConfigs.some(({ key, name }) => [key, name].includes(old.key)));
 
+const mergeConfigs = ({ old: oldConfigs, cur: newConfigs = [], did = '', dek = '' }) => {
+  const enableSecurity = dek && did;
   const isUpdatingCustomConfig = newConfigs.every((x) => x.key);
-  const configs = isUpdatingCustomConfig ? metaConfigs : metaConfigsToKeep;
+
+  const customConfigs = (oldConfigs || []).filter((x) => x.custom);
+  const appConfigs = (oldConfigs || []).filter((x) => !x.custom && !!BLOCKLET_CONFIGURABLE_KEY[x.key]);
+
+  const allMetaConfigs = (oldConfigs || []).filter((x) => !x.custom && !BLOCKLET_CONFIGURABLE_KEY[x.key]);
+  const metaConfigs = isUpdatingCustomConfig ? allMetaConfigs : removeDeletedMetaConfigs(allMetaConfigs, newConfigs);
 
   // oldConfig 表示从数据库中可以用的字段
-  const oldConfig = [...configs, ...customConfigs].reduce((acc, x) => {
+  const oldConfig = [...metaConfigs, ...appConfigs, ...customConfigs].reduce((acc, x) => {
     acc[x.key] = {
       value: x.value,
       required: x.required,
@@ -19,6 +25,7 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
       secure: x.secure || false,
       validation: x.validation || '',
       custom: x.custom,
+      shared: x.shared,
     };
     return acc;
   }, {});
@@ -27,26 +34,35 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
   const uniqConfigs = uniqBy(newConfigs, (x) => x.key || x.name);
 
   // `BLOCKLET_*` and `ABT_NODE_*`  vars can only be set by Blocklet Server Daemon with only a few exceptions.
-  const newConfig = uniqConfigs.filter((x) => {
-    const key = x.key || x.name;
-
-    if (!key) {
-      return false;
-    }
+  const newConfig = cloneDeep(
+    uniqConfigs.filter((x) => {
+      const key = x.key || x.name;
 
-    if (BLOCKLET_CONFIGURABLE_KEY[key]) {
-      return true;
-    }
+      if (!key) {
+        return false;
+      }
 
-    if (key.toString().startsWith('ABT_NODE_') || key.toString().startsWith('BLOCKLET_')) {
-      return false;
-    }
+      if (BLOCKLET_CONFIGURABLE_KEY[key]) {
+        return true;
+      }
 
-    return true;
-  });
+      return !(key.toString().startsWith('ABT_NODE_') || key.toString().startsWith('BLOCKLET_'));
+    })
+  );
+
+  if (enableSecurity) {
+    newConfig.forEach((x) => {
+      if (x.secure) {
+        x.value = security.encrypt(x.value, did, dek);
+        if (x.default) {
+          x.default = security.encrypt(x.default, did, dek);
+        }
+      }
+    });
+  }
 
   newConfig.forEach((config) => {
-    const { name, key, value, default: defaultVal, required, description, secure, validation, custom } = config;
+    const { name, key, value, default: defaultVal, required, description, secure, validation, custom, shared } = config;
     // 新增、更新或者删除
     if (key) {
       const originalVal = oldConfig[key] || {};
@@ -58,6 +74,7 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
         validation: validation || '',
         secure: secure === undefined ? false : secure,
         custom: custom === undefined ? false : custom,
+        shared,
       };
       return;
     }
@@ -65,15 +82,21 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
     if (name) {
       // 重装时 name 和 value不覆盖
       if (oldConfig[name]) {
+        const oldSecure = oldConfig[name].secure;
+        const oldValue =
+          enableSecurity && oldSecure ? security.decrypt(oldConfig[name].value, did, dek) : oldConfig[name].value;
+
+        const newSecure = secure === undefined ? false : secure;
+
         oldConfig[name] = {
-          value: oldConfig[name].value,
+          value: enableSecurity && newSecure ? security.encrypt(oldValue, did, dek) : oldValue,
           required: required === undefined ? false : required,
           description: description || '',
           validation: validation || '',
-          secure: secure === undefined ? false : secure,
+          secure: newSecure,
           custom: custom === undefined ? false : custom,
+          shared,
         };
-
         return;
       }
 
@@ -85,6 +108,7 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
         validation: validation || '',
         secure: secure === undefined ? false : secure,
         custom: custom === undefined ? false : custom,
+        shared,
       };
     }
   });
@@ -100,11 +124,44 @@ const mergeConfigs = (oldConfigs, newConfigs = []) => {
       secure: mergedObj[key].secure,
       validation: mergedObj[key].validation,
       custom: mergedObj[key].custom,
+      shared: mergedObj[key].shared,
     }));
 
   return mergedConfig;
 };
 
+const parseConfigs = ({ data, did, dek }) => {
+  const enableSecurity = dek && did;
+
+  if (enableSecurity && Array.isArray(data)) {
+    return cloneDeep(data).map((x) => {
+      if (x.secure) {
+        x.value = security.decrypt(x.value, did, dek);
+      }
+
+      return x;
+    });
+  }
+
+  return data;
+};
+
+const encryptConfigs = ({ data, did, dek }) => {
+  const enableSecurity = dek && did;
+
+  if (enableSecurity && Array.isArray(data)) {
+    data.forEach((x) => {
+      if (x.secure) {
+        x.value = security.encrypt(x.value, did, dek);
+      }
+    });
+  }
+
+  return data;
+};
+
 module.exports = {
   mergeConfigs,
+  parseConfigs,
+  encryptConfigs,
 };

package/lib/blocklet/hooks.js

@@ -1,70 +1,25 @@
-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 (processId, 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}:`, { processId, hook });
+    await runScript(hook, [processId, hookName].join(':'), { cwd: appDir, env: getSafeEnv(env), silent });
   } catch (error) {
-    logger.error(`run ${hook} error:`, { error });
+    logger.error(`run ${hook} error:`, { processId, error });
 
     if (notification) {
       notification.create({
@@ -77,33 +32,31 @@ const runUserHook = async (name, args) => {
     }
 
     if (exitOnError) {
-      throw new Error(`Run [${name}] failed: ${error.message}`);
+      throw new Error(`Run [${processId} - ${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 preInstall = (processId, ...args) => runUserHook(processId, 'pre-install', ...args);
+const postInstall = (processId, ...args) => runUserHook(processId, 'post-install', ...args);
+const preConfig = (processId, ...args) => runUserHook(processId, '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.processId, '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 postStart = (blocklet, ...args) => runUserHook(blocklet.env.processId, 'post-start', ...args);
+const preUninstall = (processId, ...args) => runUserHook(processId, 'pre-uninstall', ...args);
+const preStop = (processId, ...args) => runUserHook(processId, 'pre-stop', ...args);
 
-module.exports = { preDeploy, preInstall, postInstall, preStart, preUninstall, preStop, preConfig };
+module.exports = { preInstall, postInstall, preStart, postStart, preUninstall, preStop, preConfig };

package/lib/blocklet/manager/base.js

@@ -8,37 +8,39 @@ class BaseBlockletManager extends EventEmitter {
   constructor() {
     super();
 
+    this.setMaxListeners(100);
+
     // HACK: do not emit any events from CLI
     if (isCLI() && process.env.NODE_ENV !== 'test') {
       this.emit = (name) => logger.debug('stopped blocklet manager event in CLI', name);
     }
   }
 
-  async install(did, userVersion = 'latest') {
+  async install() {
     throw new Error('Install must be implemented in sub class');
   }
 
-  async start(did, autoDisconnect = true) {
+  async start() {
     throw new Error('Install must be implemented in sub class');
   }
 
-  async stop(did, autoDisconnect = true) {
+  async stop() {
     throw new Error('Stop must be implemented in sub class');
   }
 
-  async restart(did) {
+  async restart() {
     throw new Error('Restart must be implemented in sub class');
   }
 
-  async reload(did) {
+  async reload() {
     throw new Error('Reload must be implemented in sub class');
   }
 
-  async delete(did, disconnect = true) {
+  async delete() {
     throw new Error('Delete must be implemented in sub class');
   }
 
-  async detail(did) {
+  async detail() {
     throw new Error('Detail must be implemented in sub class');
   }
 
@@ -46,17 +48,9 @@ class BaseBlockletManager extends EventEmitter {
     throw new Error('List must be implemented in sub class');
   }
 
-  async config(did, configs) {
+  async config() {
     throw new Error('Config must be implemented in sub class');
   }
-
-  async upgrade(did, version) {
-    throw new Error('Upgrade must be implemented in sub class');
-  }
-
-  async deploy(folder) {
-    throw new Error('Deploy must be implemented in sub class');
-  }
 }
 
 module.exports = BaseBlockletManager;