@abtnode/core 1.16.11-next-069c3537 → 1.16.11-next-3d2b39f7

package/lib/blocklet/manager/helper/install-application-from-general.js

@@ -54,9 +54,7 @@ const installApplicationFromGeneral = async ({
 
   // check install count
   if (controller?.nftId) {
-    // sometimes nedb will throw error if use states.blocklet.count({ ['controller.nftId']: controller.nftId })
     const installedCount = await states.blockletExtras.count({ 'controller.nftId': controller.nftId });
-
     if (installedCount >= (controller.appMaxCount || 1)) {
       throw new Error(
         `You can only install ${controller.appMaxCount} blocklet with this credential: ${controller.nftId}`
@@ -120,7 +118,24 @@ const installApplicationFromGeneral = async ({
       },
     ]);
   } catch (err) {
-    await manager._rollback('install', did, {});
+    const componentDid = component?.meta?.did;
+    logger.error('failed to create blocklet extras', { did, componentDid, error: err });
+
+    try {
+      await manager._rollback('install', did, {});
+    } catch (e) {
+      logger.error('failed to remove blocklet on create extras error', { did, componentDid, error: e });
+    }
+
+    manager._createNotification(did, {
+      title: 'Blocklet Install Failed',
+      description: `Blocklet ${title || component?.meta?.title} install failed with error: ${err.message}`,
+      entityType: 'blocklet',
+      entityId: did,
+      severity: 'error',
+    });
+
+    throw err;
   }
 
   if (!blocklet.children.length) {

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

@@ -56,7 +56,6 @@ const installComponentFromDev = async ({ folder, meta, rootDid, mountPoint, mana
   const newBlocklet = await states.blocklet.getBlocklet(rootDid);
   await validateBlocklet(newBlocklet);
   await manager._downloadBlocklet(newBlocklet);
-  await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
 
   // Add Config
   await manager._setConfigsFromMeta(rootDid);

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

@@ -13,6 +13,7 @@ const {
   ensureMeta,
   checkStructVersion,
   checkVersionCompatibility,
+  getBlockletStatus,
 } = require('../../../util/blocklet');
 const { resolveDownload, resolveDiffDownload, downloadFromUpload } = require('../../downloader/resolve-download');
 
@@ -39,9 +40,10 @@ const installComponentFromUpload = async ({
   // 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)}`);
+  const appStatus = getBlockletStatus(oldBlocklet);
+  if (isInProgress(appStatus)) {
+    logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(appStatus)}`);
+    throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(appStatus)}`);
   }
 
   let meta;
@@ -105,6 +107,8 @@ const installComponentFromUpload = async ({
   const action = 'upgrade';
   await manager._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
 
+  const componentDids = [newChild.meta.did, ...newChildren.map((x) => x.meta.did)];
+
   await manager._downloadAndInstall({
     blocklet: newBlocklet,
     oldBlocklet,
@@ -112,7 +116,7 @@ const installComponentFromUpload = async ({
     throwOnError: true,
     postAction: action,
     skipCheckStatusBeforeDownload: true,
-    selectedComponentDids: newChildren.map((x) => x.meta.did),
+    componentDids,
   });
   return manager.getBlocklet(newBlocklet.meta.did);
 };

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

@@ -127,8 +127,10 @@ const installComponentFromUrl = async ({
     throw err;
   }
 
+  const componentDids = [newChild.meta.did, ...newChildren.map((x) => x.meta.did)];
+
   // new blocklet
-  const newBlocklet = await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.waiting);
+  const newBlocklet = await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.waiting, { componentDids });
 
   newBlocklet.children = blocklet.children;
   await validateBlocklet(newBlocklet);
@@ -138,7 +140,7 @@ const installComponentFromUrl = async ({
   const downloadParams = {
     oldBlocklet: { ...oldBlocklet },
     blocklet: { ...newBlocklet },
-    selectedComponentDids: [newChild.meta.did, ...newChildren.map((x) => x.meta.did)],
+    componentDids,
     context,
     postAction: action,
   };

package/lib/blocklet/manager/helper/upgrade-components.js

@@ -73,8 +73,8 @@ const check = async ({ did, states }) => {
   };
 };
 
-const upgrade = async ({ updateId, selectedComponentDids, context, states, manager }) => {
-  if (!selectedComponentDids?.length) {
+const upgrade = async ({ updateId, componentDids, context, states, manager }) => {
+  if (!componentDids?.length) {
     throw new Error('At least one component needs to be selected');
   }
 
@@ -87,7 +87,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   let dynamicComponents = [];
   const children = cloneDeep(oldBlocklet.children).map((oldComponent) => {
     const newComponent = sessionData.children.find((x) => x.meta.did === oldComponent.meta.did);
-    if (newComponent && selectedComponentDids.includes(newComponent.meta.did)) {
+    if (newComponent && componentDids.includes(newComponent.meta.did)) {
       dynamicComponents.push(...(newComponent._dynamicComponents || []));
       delete newComponent._dynamicComponents;
       return newComponent;
@@ -97,8 +97,8 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   dynamicComponents = filterDuplicateComponents(dynamicComponents, children);
   children.push(...dynamicComponents);
 
-  // selectedComponentDids
-  selectedComponentDids.push(...dynamicComponents.map((x) => x.meta.did));
+  // componentDids
+  componentDids.push(...dynamicComponents.map((x) => x.meta.did));
 
   checkVersionCompatibility(children);
 
@@ -108,7 +108,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   });
 
   // new blocklet
-  const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
+  const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting, { componentDids });
 
   newBlocklet.children = children;
   await validateBlocklet(newBlocklet);
@@ -128,7 +128,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
       id: did,
       oldBlocklet: { ...oldBlocklet },
       blocklet: { ...newBlocklet },
-      selectedComponentDids: selectedComponentDids || [],
+      componentDids: componentDids || [],
       context,
       postAction: action,
     },

package/lib/blocklet/manager/pm2-events.js

@@ -27,10 +27,10 @@ class BlockletPm2Events extends EventEmitter {
         if (actualPm2Home !== expectedPm2Home) {
           return;
         }
-        const { BLOCKLET_DID: blockletDid } = details.process || {};
-        logger.debug('listen pm2 event', { name, blockletDid });
+        const { BLOCKLET_DID: blockletDid, BLOCKLET_COMPONENT_DID: componentDid } = details.process || {};
+        logger.debug('listen pm2 event', { name, blockletDid, componentDid });
         if (blockletDid) {
-          this.emit(name, { blockletDid });
+          this.emit(name, { blockletDid, componentDid });
         }
       })
       .error((error) => {

package/lib/event.js

@@ -3,7 +3,13 @@ const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
 const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
-const { BLOCKLET_MODES, BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/constant');
+const {
+  BLOCKLET_MODES,
+  BlockletStatus,
+  BlockletSource,
+  BlockletEvents,
+  BlockletInternalEvents,
+} = require('@blocklet/constant');
 const { EVENTS } = require('@abtnode/constant');
 const { NodeMonitSender } = require('./monitor/node-monit-sender');
 const handleInstanceInStore = require('./util/public-to-store');
@@ -375,6 +381,10 @@ module.exports = ({
     listen(blockletManager, eventName, handleBlockletEvent);
   });
 
+  [BlockletInternalEvents.componentsUpdated, BlockletInternalEvents.appConfigChanged].forEach((eventName) => {
+    listen(blockletManager, eventName, onEvent);
+  });
+
   listen(notificationState, EVENTS.NOTIFICATION_CREATE, onEvent);
 
   listen(nodeState, BlockletEvents.purchaseChange, onEvent);

package/lib/index.js

@@ -16,6 +16,7 @@ const getRouterHelpers = require('./router/helper');
 const TeamManager = require('./team/manager');
 const NodeAPI = require('./api/node');
 const TeamAPI = require('./api/team');
+const { getLauncherSession, isLauncherSessionConsumed, setupAppOwner } = require('./util/launcher');
 const WebHook = require('./webhook');
 const states = require('./states');
 const Cert = require('./cert');
@@ -250,7 +251,6 @@ function ABTNode(options) {
     devBlocklet: blockletManager.dev.bind(blockletManager),
     checkComponentsForUpdates: blockletManager.checkComponentsForUpdates.bind(blockletManager),
     upgradeComponents: blockletManager.upgradeComponents.bind(blockletManager),
-    getBlockletMetaFromUrl: getMetaFromUrl.bind(blockletManager),
     getBlockletForLauncher: blockletManager.getBlockletForLauncher.bind(blockletManager),
     resetBlocklet: blockletManager.reset.bind(blockletManager),
     deleteBlockletProcess: blockletManager.deleteProcess.bind(blockletManager),
@@ -266,9 +266,7 @@ function ABTNode(options) {
     migrateApplicationToStructV2: blockletManager.migrateApplicationToStructV2.bind(blockletManager),
 
     // For diagnose purpose
-    syncBlockletStatus: blockletManager.status.bind(blockletManager),
     ensureBlockletIntegrity: blockletManager.ensureBlocklet.bind(blockletManager),
-    updateBlockletStatus: states.blocklet.setBlockletStatus.bind(states.blocklet),
 
     getBlocklets: blockletManager.list.bind(blockletManager),
     getBlockletsFromBackup: blockletManager.listBackups.bind(blockletManager),
@@ -462,6 +460,12 @@ function ABTNode(options) {
 
     // for exporting blocklet data dir
     createBlockletDataArchive: createDataArchive,
+
+    // public utils used in launch workflow
+    getBlockletMetaFromUrl: getMetaFromUrl,
+    getLauncherSession,
+    isLauncherSessionConsumed,
+    setupAppOwner,
   };
 
   const events = createEvents({

package/lib/migrations/1.16.11-component-status.js

@@ -0,0 +1,22 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update component status...');
+
+  const apps = await states.blocklet.find({});
+
+  for (const app of apps || []) {
+    const appStatus = app.status;
+    let shouldUpdate = false;
+    for (const component of app.children || []) {
+      shouldUpdate = true;
+      component.status = appStatus;
+    }
+
+    if (shouldUpdate) {
+      await states.blocklet.update({ id: app.id }, { $set: { children: app.children } });
+      printInfo(`Blocklet in blocklet.db updated: ${app.meta?.title}. status: ${appStatus}`);
+    }
+  }
+};

package/lib/monitor/blocklet-runtime-monitor.js

@@ -116,7 +116,7 @@ class BlockletRuntimeMonitor extends EventEmitter {
     await forEachBlocklet(
       blocklet,
       async (component, { id: componentId, ancestors }) => {
-        if (component.meta.group !== BlockletGroup.gateway) {
+        if (component.meta.group !== BlockletGroup.gateway && component.status === BlockletStatus.running) {
           const processId = getComponentProcessId(component, ancestors);
           try {
             const runtimeInfo = await getRuntimeInfo(processId);
@@ -132,6 +132,8 @@ class BlockletRuntimeMonitor extends EventEmitter {
           } catch (err) {
             this.logger.error('failed to get blocklet runtime info', { processId, error: err });
           }
+        } else {
+          delete this.data[blockletDid][componentId];
         }
       },
       { parallel: true }

package/lib/states/blocklet-extras.js

@@ -226,6 +226,16 @@ class BlockletExtrasState extends BaseState {
     return docs.filter((x) => x.controller?.nftId).filter((x) => x.expiredAt <= deadline);
   }
 
+  async isLauncherSessionConsumed(sessionId) {
+    const count = await super.count({ 'controller.sessionId': sessionId });
+    return count > 0;
+  }
+
+  async isLauncherNftConsumed(nftId) {
+    const count = await super.count({ 'controller.nftId': nftId });
+    return count > 0;
+  }
+
   encryptSecurityData({ data, _rootDid } = {}) {
     if (!data) {
       return data;

package/lib/states/blocklet.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
+const pick = require('lodash/pick');
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const cloneDeep = require('lodash/cloneDeep');
@@ -13,17 +14,23 @@ const {
   getDisplayName,
   forEachBlocklet,
   forEachBlockletSync,
-  forEachChildSync,
+  forEachComponentV2Sync,
   getBlockletServices,
 } = require('@blocklet/meta/lib/util');
-const { BlockletStatus, BlockletSource, BLOCKLET_MODES, BLOCKLET_DEFAULT_PORT_NAME } = require('@blocklet/constant');
+const {
+  BlockletStatus,
+  BlockletSource,
+  BLOCKLET_MODES,
+  BLOCKLET_DEFAULT_PORT_NAME,
+  BlockletGroup,
+} = require('@blocklet/constant');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet');
 
 const BaseState = require('./base');
 const { checkDuplicateComponents, ensureMeta } = require('../util/blocklet');
-const { validateBlockletMeta } = require('../util/blocklet');
+const { validateBlockletMeta, getBlockletStatus, shouldSkipComponent } = require('../util/blocklet');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
@@ -37,6 +44,10 @@ const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
 const formatBlocklet = (blocklet, phase, dek) => {
+  if (phase === 'onRead') {
+    blocklet.status = getBlockletStatus(blocklet);
+  }
+
   forEachBlockletSync(blocklet, (b) => {
     if (b.meta) {
       fixPerson(b.meta);
@@ -273,6 +284,9 @@ class BlockletState extends BaseState {
 
     const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.config.dek);
     const [, [updated]] = await this.update({ id: doc.id }, { $set: formatted });
+
+    updated.status = getBlockletStatus(updated);
+
     return updated;
   }
 
@@ -480,62 +494,55 @@ class BlockletState extends BaseState {
   }
 
   /**
-   * @param {String} did blocklet did
+   * @param {Did} did blocklet did
    * @param {BlockletStatus} status blocklet status
-   *
-   * children status only different with parent before blocklet installation
-   * @param {Array<componentId>} children
+   * @param {{
+   *   componentDids?: Array<Did>
+   * }}
    */
-  async setBlockletStatus(did, status, { children } = {}) {
+  async setBlockletStatus(did, status, { componentDids } = {}) {
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }
 
     const doc = await this.getBlocklet(did);
-    if (doc.status === status && !children) {
-      return formatBlocklet(doc, 'onRead', this.config.dek);
-    }
 
-    const updates = { status, startedAt: null, stoppedAt: null };
-    if (status === BlockletStatus.running) {
-      updates.startedAt = new Date();
-    }
-    if (status === BlockletStatus.installed) {
-      updates.installedAt = new Date();
+    if (doc.meta?.group === BlockletGroup.gateway && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
-    if (status === BlockletStatus.stopped) {
-      updates.stoppedAt = new Date();
+
+    // for backward compatibility
+    if (!doc.structVersion && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
 
     // update children status
-    forEachChildSync(doc, (child, { id }) => {
-      if (children === 'all') {
-        child.status = status;
+    forEachComponentV2Sync(doc, (component) => {
+      if (component.meta.group === BlockletGroup.gateway) {
         return;
       }
 
-      if (!children) {
-        if (
-          ![
-            BlockletStatus.waiting,
-            BlockletStatus.upgrading,
-            BlockletStatus.installing,
-            BlockletStatus.starting,
-          ].includes(status)
-        ) {
-          child.status = status;
-        }
-
+      if (shouldSkipComponent(component.meta.did, componentDids)) {
         return;
       }
 
-      if (children.includes(id)) {
-        child.status = status;
+      component.status = status;
+      if (status === BlockletStatus.running) {
+        component.startedAt = new Date();
+        component.stoppedAt = null;
+      }
+      if (status === BlockletStatus.stopped) {
+        component.startedAt = null;
+        component.stoppedAt = new Date();
       }
     });
 
-    updates.children = doc.children;
-    return this.updateBlocklet(did, updates);
+    return this.updateBlocklet(did, pick(doc, ['status', 'children']));
+  }
+
+  async setInstalledAt(did) {
+    logger.info('setInstalledAt', { did });
+    return this.updateBlocklet(did, { installedAt: new Date() });
   }
 
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren, returnMaxPort } = {}) {

package/lib/states/node.js

@@ -253,6 +253,7 @@ class NodeState extends BaseState {
   async getEnvironments() {
     return this.read().then((info) => ({
       ABT_NODE: info.version,
+      ABT_NODE_VERSION: info.version,
       ABT_NODE_DID: info.did,
       ABT_NODE_SK: info.sk,
       ABT_NODE_PK: info.pk,