@abtnode/core 1.7.18 → 1.7.21

package/lib/states/blocklet.js

@@ -9,7 +9,7 @@ const detectPort = require('detect-port');
 const Lock = require('@abtnode/util/lib/lock');
 const security = require('@abtnode/util/lib/security');
 const { fixPerson, fixInterfaces } = require('@blocklet/meta/lib/fix');
-const { getDisplayName, forEachBlocklet } = require('@blocklet/meta/lib/util');
+const { getDisplayName, forEachBlocklet, forEachBlockletSync, forEachChildSync } = require('@blocklet/meta/lib/util');
 const {
   BlockletStatus,
   BlockletSource,
@@ -33,35 +33,31 @@ const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
 const formatBlocklet = (blocklet, phase, dek) => {
-  forEachBlocklet(
-    blocklet,
-    (b) => {
-      if (b.meta) {
-        fixPerson(b.meta);
-        fixInterfaces(b.meta);
-      }
+  forEachBlockletSync(blocklet, (b) => {
+    if (b.meta) {
+      fixPerson(b.meta);
+      fixInterfaces(b.meta);
+    }
 
-      b.children = b.children || [];
+    b.children = b.children || [];
+
+    if (!b.environments || !b.meta || !dek) {
+      return;
+    }
 
-      if (!b.environments || !b.meta || !dek) {
+    ['BLOCKLET_APP_SK'].forEach((key) => {
+      const env = b.environments.find((x) => x.key === key);
+      if (!env) {
         return;
       }
-
-      ['BLOCKLET_APP_SK'].forEach((key) => {
-        const env = b.environments.find((x) => x.key === key);
-        if (!env) {
-          return;
-        }
-        if (phase === 'onUpdate' && isHex(env.value) === true) {
-          env.value = security.encrypt(env.value, b.meta.did, dek);
-        }
-        if (phase === 'onRead' && isHex(env.value) === false) {
-          env.value = security.decrypt(env.value, b.meta.did, dek);
-        }
-      });
-    },
-    { sync: true }
-  );
+      if (phase === 'onUpdate' && isHex(env.value) === true) {
+        env.value = security.encrypt(env.value, b.meta.did, dek);
+      }
+      if (phase === 'onRead' && isHex(env.value) === false) {
+        env.value = security.decrypt(env.value, b.meta.did, dek);
+      }
+    });
+  });
 
   return blocklet;
 };
@@ -416,7 +412,7 @@ class BlockletState extends BaseState {
    * @param {BlockletStatus} status blocklet status
    *
    * children status only different with parent before blocklet installation
-   * @param {Array<{did}>} children
+   * @param {Array<componentId>} children
    */
   async setBlockletStatus(did, status, { children } = {}) {
     if (typeof status === 'undefined') {
@@ -440,44 +436,45 @@ class BlockletState extends BaseState {
     }
 
     // update children status
-    updates.children = doc.children.map((child) => {
+    forEachChildSync(doc, (child, { id }) => {
       if (children === 'all') {
         child.status = status;
-        return child;
+        return;
       }
 
       if (!children) {
-        if (![BlockletStatus.waiting, BlockletStatus.upgrading, BlockletStatus.installing].includes(status)) {
+        if (
+          ![
+            BlockletStatus.waiting,
+            BlockletStatus.upgrading,
+            BlockletStatus.installing,
+            BlockletStatus.starting,
+          ].includes(status)
+        ) {
           child.status = status;
         }
 
-        return child;
+        return;
       }
 
-      const inputChild = children.find((x) => x.did === child.meta.did);
-      if (inputChild) {
+      if (children.includes(id)) {
         child.status = status;
       }
-      return child;
     });
 
+    updates.children = doc.children;
     return this.updateBlocklet(did, updates);
   }
 
-  async fillChildrenPorts(children, { defaultPort = 0, oldChildren } = {}) {
+  async fillChildrenPorts(children, { defaultPort = 0, oldChildren, returnMaxPort } = {}) {
     let _maxPort = defaultPort;
     for (const child of children || []) {
       // generate ports
       const childMeta = child.meta;
+      const oldChild = (oldChildren || []).find((x) => x.meta.did === child.meta.did);
 
       // get skipOccupiedCheckPorts
-      let skipOccupiedCheckPorts = [];
-      if (Array.isArray(oldChildren)) {
-        const oldChild = oldChildren.find((x) => x.meta.did === child.meta.did);
-        if (oldChild) {
-          skipOccupiedCheckPorts = getExternalPortsFromMeta(oldChild.meta);
-        }
-      }
+      const skipOccupiedCheckPorts = oldChild ? getExternalPortsFromMeta(oldChild.meta) : [];
 
       const ports = await this.getBlockletPorts({
         interfaces: childMeta.interfaces || [],
@@ -486,22 +483,17 @@ class BlockletState extends BaseState {
       });
       _maxPort = getMaxPort(ports);
 
-      // fill old child's port to new child
-      if (Array.isArray(oldChildren)) {
-        const oldChild = oldChildren.find((x) => x.meta.did === child.meta.did);
-        if (oldChild && oldChild.ports) {
-          logger.info('Merge the previous ports to child blocklet', {
-            did: child.meta.did,
-            name: child.meta.name,
-            oldPorts: oldChild.ports,
-            ports,
-          });
-          Object.keys(ports).forEach((p) => {
-            ports[p] = oldChild.ports[p] || ports[p];
-          });
-          child.ports = ports;
-          continue; // eslint-disable-line
-        }
+      if (oldChild && oldChild.ports) {
+        // fill old child's port to new child
+        logger.info('Merge the previous ports to child blocklet', {
+          did: child.meta.did,
+          name: child.meta.name,
+          oldPorts: oldChild.ports,
+          ports,
+        });
+        Object.keys(ports).forEach((p) => {
+          ports[p] = oldChild.ports[p] || ports[p];
+        });
       }
 
       // assign a new port to child
@@ -509,6 +501,20 @@ class BlockletState extends BaseState {
       child.ports = ports;
     }
 
+    for (const child of children || []) {
+      const oldChild = (oldChildren || []).find((x) => x.meta.did === child.meta.did);
+
+      _maxPort = await this.fillChildrenPorts(child.children || [], {
+        defaultPort: _maxPort,
+        oldChildren: oldChild?.children,
+        returnMaxPort: true,
+      });
+    }
+
+    if (returnMaxPort) {
+      return _maxPort;
+    }
+
     return children;
   }
 
@@ -528,10 +534,6 @@ class BlockletState extends BaseState {
         throw new Error(`mountPoint is required when adding component ${getDisplayName(child, true)}`);
       }
 
-      if (meta.did === parent.meta.did) {
-        throw new Error('Cannot add self as a component');
-      }
-
       checkDuplicateComponents([child, ...newChildren]);
 
       newChildren.push({
@@ -543,6 +545,7 @@ class BlockletState extends BaseState {
         mode,
         dynamic: true,
         status: BlockletStatus.added,
+        children: child.children,
       });
 
       fixChildren(newChildren);

package/lib/states/node.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-underscore-dangle */
 const semver = require('semver');
 const omit = require('lodash/omit');
-const isEqual = require('lodash/isEqual');
 const isEmpty = require('lodash/isEmpty');
 const security = require('@abtnode/util/lib/security');
 const { isFromPublicKey } = require('@arcblock/did');
@@ -215,32 +214,43 @@ class NodeState extends BaseState {
     return updateResult;
   }
 
-  async addNodeOwner(owner) {
-    if (!validateOwner(owner)) {
+  async updateNodeOwner({ nodeOwner, ownerNft }) {
+    if (!validateOwner(nodeOwner)) {
       throw new Error('Node owner is invalid');
     }
 
     const doc = await this.read();
 
-    if (doc.nodeOwner) {
-      if (isEqual(owner, doc.nodeOwner)) {
-        return doc;
-      }
+    const initialized = this.isInitialized({ nodeOwner });
+
+    if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
+      this.notification.setDefaultReceiver(nodeOwner.did);
+    }
 
-      throw new Error('Cannot set owner because owner already exists');
+    const entities = { nodeOwner, initialized, initializedAt: initialized ? new Date() : null };
+    if (ownerNft) {
+      entities.ownerNft = ownerNft;
     }
 
-    return this.addOwner(owner, doc);
+    const updateResult = await this.update(doc._id, {
+      $set: entities,
+    });
+
+    this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
+
+    return updateResult;
   }
 
-  async updateNodeOwner(owner) {
-    if (!validateOwner(owner)) {
-      throw new Error('Node owner is invalid');
+  async updateNftHolder(holder) {
+    if (!holder) {
+      throw new Error('NFT holder can not be empty');
     }
 
     const doc = await this.read();
 
-    return this.addOwner(owner, doc);
+    return this.update(doc._id, {
+      $set: { 'ownerNft.holder': holder },
+    });
   }
 
   async enterMode(mode) {