@abtnode/core 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/blocklet/manager/helper/install-component-from-upload.js

@@ -0,0 +1,181 @@
+const path = require('path');
+
+const logger = require('@abtnode/logger')('@abtnode/core:install-component-upload');
+const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
+
+const { BlockletSource, BlockletGroup, fromBlockletStatus } = require('@blocklet/constant');
+const { isInProgress } = require('../../../util');
+const {
+  parseComponents,
+  filterDuplicateComponents,
+  getDiffFiles,
+  getBundleDir,
+  ensureMeta,
+  checkStructVersion,
+  checkVersionCompatibility,
+} = require('../../../util/blocklet');
+const { resolveDownload, resolveDiffDownload, downloadFromUpload } = require('../../downloader/resolve-download');
+
+const installComponentFromUpload = async ({
+  rootDid,
+  mountPoint,
+  file,
+  did,
+  diffVersion,
+  deleteSet,
+  context = {},
+  manager,
+  states,
+}) => {
+  logger.info('install component', { from: 'upload file' });
+
+  const oldBlocklet = await manager._getBlockletForInstallation(rootDid);
+  if (!oldBlocklet) {
+    throw new Error('Root blocklet does not exist');
+  }
+
+  checkStructVersion(oldBlocklet);
+
+  // download
+  const { tarFile } = await downloadFromUpload(file, { downloadDir: path.join(manager.dataDirs.tmp, 'download') });
+
+  if (isInProgress(oldBlocklet.status)) {
+    logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
+    throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
+  }
+
+  let meta;
+  // diff upload
+  if (did && diffVersion) {
+    const oldChild = oldBlocklet.children.find((x) => x.meta.did === did);
+    if (!oldChild) {
+      throw new Error(`Blocklet ${did} not found when diff deploying`);
+    }
+    if (oldChild.meta.version !== diffVersion) {
+      logger.error('Diff deploy: Blocklet version changed', {
+        preVersion: diffVersion,
+        changedVersion: oldChild.meta.version,
+        name: oldChild.meta.name,
+        did: oldChild.meta.did,
+      });
+      throw new Error('Blocklet version changed when diff deploying');
+    }
+
+    meta = (await resolveDiffDownload(tarFile, manager.installDir, { deleteSet, meta: oldChild.meta })).meta;
+  } else {
+    // full deploy
+    meta = (await resolveDownload(tarFile, manager.installDir)).meta;
+  }
+
+  if (meta.did === rootDid) {
+    // should not be here
+    throw new Error('Cannot add self as a component');
+  }
+
+  if (meta.group === BlockletGroup.gateway) {
+    throw new Error('Cannot add gateway component');
+  }
+
+  const newBlocklet = await states.blocklet.getBlocklet(rootDid);
+
+  const newChild = {
+    meta: ensureMeta(meta),
+    mountPoint,
+    source: BlockletSource.upload,
+    deployedFrom: `Upload by ${context.user.fullName}`,
+    bundleSource: null,
+  };
+  const index = newBlocklet.children.findIndex((child) => child.meta.did === meta.did);
+  if (index >= 0) {
+    // if upgrade, do not update mountPoint and title
+    newChild.mountPoint = newBlocklet.children[index].mountPoint;
+    newChild.meta.title = newBlocklet.children[index].meta.title;
+    newBlocklet.children.splice(index, 1, newChild);
+  } else {
+    newBlocklet.children.push(newChild);
+  }
+
+  const { dynamicComponents } = await parseComponents(newChild);
+  const newChildren = filterDuplicateComponents(dynamicComponents, newBlocklet.children);
+
+  newBlocklet.children.push(...newChildren);
+
+  checkVersionCompatibility(newBlocklet.children);
+
+  // backup rollback data
+  const action = 'upgrade';
+  await manager._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
+
+  await manager._downloadAndInstall({
+    blocklet: newBlocklet,
+    oldBlocklet,
+    context: { ...context, forceStartProcessIds: [getComponentProcessId(newChild, [newBlocklet])] },
+    throwOnError: true,
+    postAction: action,
+    skipCheckStatusBeforeDownload: true,
+    selectedComponentDids: newChildren.map((x) => x.meta.did),
+  });
+  return manager.getBlocklet(newBlocklet.meta.did);
+};
+
+const diff = async ({ did, hashFiles: clientFiles, rootDid: inputRootDid, states, manager }) => {
+  if (!did) {
+    throw new Error('did is empty');
+  }
+
+  if (!clientFiles || !clientFiles.length) {
+    throw new Error('hashFiles is empty');
+  }
+
+  const rootDid = inputRootDid || did;
+  const childDid = inputRootDid ? did : '';
+
+  if (childDid === rootDid) {
+    throw new Error('Cannot add self as a component');
+  }
+
+  logger.info('Get blocklet diff', { rootDid, childDid, clientFilesNumber: clientFiles.length });
+
+  const rootBlocklet = await states.blocklet.getBlocklet(rootDid);
+  if (childDid && !rootBlocklet) {
+    throw new Error('Root blocklet does not exist');
+  }
+
+  const state = childDid ? await (rootBlocklet.children || []).find((x) => x.meta.did === childDid) : rootBlocklet;
+
+  if (!state) {
+    return {
+      hasBlocklet: false,
+    };
+  }
+
+  if (state.source === BlockletSource.local) {
+    throw new Error(`Blocklet ${state.meta.name} is already deployed from local, can not deployed from remote.`);
+  }
+
+  const { version } = state.meta;
+  const bundleDir = getBundleDir(manager.installDir, state.meta);
+  const { addSet, changeSet, deleteSet } = await getDiffFiles(clientFiles, bundleDir);
+
+  logger.info('Diff files', {
+    name: state.meta.name,
+    did: state.meta.did,
+    version: state.meta.version,
+    addNum: addSet.length,
+    changeNum: changeSet.length,
+    deleteNum: deleteSet.length,
+  });
+
+  return {
+    hasBlocklet: true,
+    version,
+    addSet,
+    changeSet,
+    deleteSet,
+  };
+};
+
+module.exports = {
+  installComponentFromUpload,
+  diff,
+};

package/lib/blocklet/manager/helper/install-component-from-url.js

@@ -0,0 +1,173 @@
+const capitalize = require('lodash/capitalize');
+const { sign } = require('@arcblock/jwt');
+
+const logger = require('@abtnode/logger')('@abtnode/core:install-component-url');
+
+const { isFreeBlocklet, isComponentBlocklet } = require('@blocklet/meta/lib/util');
+const { titleSchema } = require('@blocklet/meta/lib/schema');
+const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
+
+const { BlockletStatus, BlockletEvents, BlockletGroup } = require('@blocklet/constant');
+const {
+  getBlockletMetaFromUrl,
+  parseComponents,
+  filterDuplicateComponents,
+  ensureMeta,
+  checkStructVersion,
+  checkVersionCompatibility,
+  validateBlocklet,
+} = require('../../../util/blocklet');
+const StoreUtil = require('../../../util/store');
+const { formatName } = require('../../../util/get-domain-for-blocklet');
+
+const installComponentFromUrl = async ({
+  rootDid,
+  mountPoint,
+  url,
+  context,
+  title,
+  configs,
+  downloadTokenList,
+  sync,
+  manager,
+  states,
+}) => {
+  const blocklet = await states.blocklet.getBlocklet(rootDid);
+  if (!blocklet) {
+    throw new Error('Root blocklet does not exist');
+  }
+
+  checkStructVersion(blocklet);
+
+  const { inStore } = await StoreUtil.parseSourceUrl(url);
+
+  const meta = await getBlockletMetaFromUrl(url);
+
+  if (meta.group === BlockletGroup.gateway) {
+    throw new Error('Cannot add gateway component');
+  }
+
+  // 如果是一个付费的blocklet,并且url来源为Store, 需要携带token才能下载成功
+  if (!isFreeBlocklet(meta) && inStore) {
+    const info = await states.node.read();
+
+    // eslint-disable-next-line no-param-reassign
+    context = {
+      ...context,
+      headers: {
+        'x-server-did': info.did,
+        'x-server-public-key': info.pk,
+        'x-server-signature': sign(info.did, info.sk, {
+          exp: (Date.now() + 5 * 60 * 1000) / 1000,
+        }),
+      },
+      downloadTokenList: downloadTokenList || [],
+    };
+  }
+
+  if (!isComponentBlocklet(meta)) {
+    throw new Error('The blocklet cannot be a component');
+  }
+
+  if (title) {
+    meta.title = await titleSchema.validateAsync(title);
+  }
+
+  const newChildMeta = ensureMeta(meta);
+
+  // children
+  const newChild = {
+    meta: newChildMeta,
+    mountPoint: mountPoint || formatName(newChildMeta.name),
+    bundleSource: { url },
+  };
+
+  const { dynamicComponents } = await parseComponents(newChild);
+
+  const index = blocklet.children.findIndex((child) => child.meta.did === meta.did);
+  if (index >= 0) {
+    // if upgrade, do not update mountPoint and title
+    newChild.mountPoint = blocklet.children[index].mountPoint;
+    newChild.meta.title = blocklet.children[index].meta.title;
+    blocklet.children.splice(index, 1, newChild);
+  } else {
+    dynamicComponents.unshift(newChild);
+  }
+
+  const newChildren = filterDuplicateComponents(dynamicComponents, blocklet.children);
+
+  blocklet.children.push(...newChildren);
+
+  checkVersionCompatibility(blocklet.children);
+
+  const oldBlocklet = await manager._getBlockletForInstallation(rootDid);
+  const action = 'upgrade';
+  try {
+    // add component to db
+    await states.blocklet.addChildren(rootDid, newChildren);
+
+    // update configs
+    if (Array.isArray(configs)) {
+      if (hasReservedKey(configs)) {
+        throw new Error('Component key of environments can not start with `ABT_NODE_` or `BLOCKLET_`');
+      }
+
+      await states.blockletExtras.setConfigs([blocklet.meta.did, newChild.meta.did], configs);
+    }
+  } catch (err) {
+    logger.error('Add component failed', err);
+    await manager._rollback(action, rootDid, oldBlocklet);
+    throw err;
+  }
+
+  // new blocklet
+  const newBlocklet = await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.waiting);
+
+  newBlocklet.children = blocklet.children;
+  await validateBlocklet(newBlocklet);
+
+  manager.emit(BlockletEvents.statusChange, newBlocklet);
+
+  const downloadParams = {
+    oldBlocklet: { ...oldBlocklet },
+    blocklet: { ...newBlocklet },
+    selectedComponentDids: [newChild.meta.did, ...newChildren.map((x) => x.meta.did)],
+    context,
+    postAction: action,
+  };
+
+  // backup rollback data
+  await manager._rollbackCache.backup({ did: rootDid, action, oldBlocklet });
+
+  if (sync) {
+    await manager._downloadAndInstall({ ...downloadParams, throwOnError: true });
+    return states.blocklet.getBlocklet(rootDid);
+  }
+
+  // add to queue
+  const ticket = manager.installQueue.push(
+    {
+      entity: 'blocklet',
+      action: 'download',
+      id: rootDid,
+      ...downloadParams,
+    },
+    rootDid
+  );
+
+  ticket.on('failed', async (err) => {
+    logger.error('queue failed', { entity: 'blocklet', action, did: rootDid, error: err });
+    await manager._rollback(action, rootDid, oldBlocklet);
+    manager.emit(`blocklet.${action}.failed`, { did: rootDid, err });
+    manager._createNotification(rootDid, {
+      title: `Blocklet ${capitalize(action)} Failed`,
+      description: `Blocklet ${rootDid} ${action} failed with error: ${err.message || 'queue exception'}`,
+      entityType: 'blocklet',
+      entityId: rootDid,
+      severity: 'error',
+    });
+  });
+  return newBlocklet;
+};
+
+module.exports = { installComponentFromUrl };