@abtnode/core 1.16.52-beta-20251005-235515-42ad5caf → 1.16.52-beta-20251008-091027-c46c73e3

package/lib/api/team.js

@@ -2792,14 +2792,21 @@ class TeamAPI extends EventEmitter {
     try {
       const state = await this.getOrgState(teamDid);
       const { passports, orgs, ...rest } = await state.list(payload, context);
-      // 获取每个组织的 passports
-      const orgPassports = await Promise.all(orgs.map((o) => this.getRoles({ teamDid, orgId: o.id })));
-
-      orgs.forEach((o, index) => {
-        const roles = orgPassports[index]; // 获取每个组织的角色
-        // 过滤 passports
-        o.passports = passports.filter((p) => roles.some((r) => r.name === p.name));
-      });
+      const { includePassports = true } = payload.options || {};
+      if (includePassports) {
+        // 获取每个组织的 passports
+        const orgPassports = await Promise.all(orgs.map((o) => this.getRoles({ teamDid, orgId: o.id })));
+
+        orgs.forEach((o, index) => {
+          const roles = orgPassports[index]; // 获取每个组织的角色
+          // 过滤 passports
+          o.passports = passports.filter((p) => roles.some((r) => r.name === p.name));
+        });
+      } else {
+        orgs.forEach((o) => {
+          o.passports = [];
+        });
+      }
 
       return {
         ...rest,
@@ -2848,7 +2855,12 @@ class TeamAPI extends EventEmitter {
       }
 
       const state = await this.getOrgState(teamDid);
-      const blocklet = await getBlocklet({ did: teamDid, states: this.states, dataDirs: this.dataDirs });
+      const blocklet = await getBlocklet({
+        did: teamDid,
+        states: this.states,
+        dataDirs: this.dataDirs,
+        useCache: true,
+      });
       const orgCount = await state.getOrgCountByUser(context.user.did);
 
       const { veriftMaxOrgPerUser } = createOrgValidators(blocklet);
@@ -2859,13 +2871,15 @@ class TeamAPI extends EventEmitter {
 
       // 创建 org 的 owner passport, 并赋值给 owner
       const roleName = md5(`${result.id}-owner`); // 避免 name 重复
-      await this.createRole({ teamDid, name: roleName, title: result.name, description: 'Owner', orgId: result.id });
-      await this.issuePassportToUser({
-        teamDid,
-        userDid: result.ownerDid,
-        role: roleName,
-        notification: {},
-      });
+      await Promise.all([
+        this.createRole({ teamDid, name: roleName, title: result.name, description: 'Owner', orgId: result.id }),
+        this.issuePassportToUser({
+          teamDid,
+          userDid: result.ownerDid,
+          role: roleName,
+          notification: {},
+        }),
+      ]);
 
       return result;
     } catch (err) {

package/lib/blocklet/manager/disk.js

@@ -2959,6 +2959,7 @@ class DiskBlockletManager extends BaseBlockletManager {
       };
     }
 
+    let shouldRotateSession = false;
     if (!isNil(org)) {
       const ORG_SCHEMA = Joi.object({
         enabled: Joi.boolean().required(),
@@ -2969,6 +2970,11 @@ class DiskBlockletManager extends BaseBlockletManager {
       if (error) {
         throw new CustomError(400, error.message);
       }
+      const currentState = await this.getBlocklet(did, { useCache: true });
+      const orgEnabled = get(currentState, 'settings.org.enabled', false);
+      if (orgEnabled !== org.enabled) {
+        shouldRotateSession = true;
+      }
       params.org = org;
     }
 
@@ -2989,6 +2995,10 @@ class DiskBlockletManager extends BaseBlockletManager {
     this.emit(BlockletInternalEvents.appSettingChanged, { appDid: did });
     this.emit(BlockletEvents.updated, { ...newState, context });
 
+    if (shouldRotateSession) {
+      this.teamAPI.rotateSessionKey({ teamDid: did });
+    }
+
     return newState;
   }
 
@@ -3519,26 +3529,30 @@ class DiskBlockletManager extends BaseBlockletManager {
         isGreen,
       });
 
-      const res = await this.getBlocklet(did);
+      if (needUpdateBlueStatus) {
+        await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
+          componentDids,
+          isGreen: !isGreen,
+        });
+      }
+
+      const nextBlocklet = await this.getBlocklet(did);
 
+      await this.configSynchronizer.throttledSyncAppConfig(nextBlocklet);
+      const componentsInfo = getComponentsInternalInfo(nextBlocklet);
       this.emit(BlockletInternalEvents.componentStarted, {
         appDid: blocklet.appDid,
-        components: (componentDids || []).map((x) => ({ did: x })),
+        components: componentsInfo,
       });
-      this.configSynchronizer.throttledSyncAppConfig(res);
 
-      this.emit(BlockletEvents.statusChange, res);
-      this.emit(BlockletEvents.started, { ...res, componentDids });
+      this.emit(BlockletEvents.statusChange, nextBlocklet);
+      this.emit(BlockletEvents.started, { ...nextBlocklet, componentDids });
 
       launcher.notifyBlockletStarted(blocklet);
 
       logger.info('blocklet healthy', { did, name, time: Date.now() - startedAt });
 
       if (needUpdateBlueStatus) {
-        await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, {
-          componentDids,
-          isGreen: !isGreen,
-        });
         try {
           await this.deleteProcess({ did, componentDids, isGreen: !isGreen }, context);
         } catch {

package/lib/blocklet/manager/helper/blue-green-start-blocklet.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-await-in-loop */
 const logger = require('@abtnode/logger')('@abtnode/core:blocklet-manager:blue-green');
-const { BlockletStatus, BlockletGroup, BlockletEvents } = require('@blocklet/constant');
+const { BlockletStatus, BlockletGroup, BlockletEvents, BlockletInternalEvents } = require('@blocklet/constant');
 const {
   hasRunnableComponent,
   getDisplayName,
@@ -9,6 +9,7 @@ const {
   getComponentMissingConfigs,
 } = require('@blocklet/meta/lib/util');
 const { getBlockletEngine, hasStartEngine } = require('@blocklet/meta/lib/engine');
+const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
 const {
   forEachBlocklet,
   validateBlocklet,
@@ -168,123 +169,131 @@ const blueGreenStartBlocklet = async (
   const blueGreenComponentIds = await blueGreenGetComponentIds(blocklet1, entryComponentIds);
 
   // eslint-disable-next-line no-unreachable-loop
-  await Promise.all(
-    blueGreenComponentIds.map(async (item) => {
-      if (!item.componentDids.length) {
-        return;
-      }
-      const nextBlocklet = await ensureAppPortsNotOccupied({
-        blocklet: blocklet1,
+  for (const item of blueGreenComponentIds) {
+    if (!item.componentDids.length) {
+      continue;
+    }
+    const nextBlocklet = await ensureAppPortsNotOccupied({
+      blocklet: blocklet1,
+      componentDids: item.componentDids,
+      states,
+      manager,
+      isGreen: item.changeToGreen,
+    });
+
+    try {
+      const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, {
         componentDids: item.componentDids,
-        states,
-        manager,
+        operator,
         isGreen: item.changeToGreen,
       });
-      try {
-        const doc1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, {
-          componentDids: item.componentDids,
-          operator,
-          isGreen: item.changeToGreen,
-        });
-        nextBlocklet.greenStatus = BlockletStatus.starting;
-        manager.emit(BlockletEvents.statusChange, doc1);
+      nextBlocklet.greenStatus = BlockletStatus.starting;
+      manager.emit(BlockletEvents.statusChange, doc1);
 
-        const nodeInfo = await states.node.read();
-        const nodeEnvironments = await states.node.getEnvironments();
+      const nodeInfo = await states.node.read();
+      const nodeEnvironments = await states.node.getEnvironments();
 
-        // 钩子函数设置
-        const getHookFn =
-          (hookName) =>
-          async (b, { env }) => {
-            const hookArgs = getHookArgs(b);
-            const needRunDocker = await checkNeedRunDocker(b.meta, env, nodeInfo, isExternalBlocklet(nextBlocklet));
-            if (!b.meta.scripts?.[hookName]) {
-              return null;
-            }
-            if (needRunDocker) {
-              return dockerExec({
-                blocklet: nextBlocklet,
-                meta: b.meta,
-                script: b.meta.scripts?.[hookName],
-                hookName,
-                nodeInfo,
-                env,
-                ...hookArgs,
-              });
-            }
-            return hooks[hookName](b, {
-              appDir: b.env.appDir,
-              hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+      // 钩子函数设置
+      const getHookFn =
+        (hookName) =>
+        async (b, { env }) => {
+          const hookArgs = getHookArgs(b);
+          const needRunDocker = await checkNeedRunDocker(b.meta, env, nodeInfo, isExternalBlocklet(nextBlocklet));
+          if (!b.meta.scripts?.[hookName]) {
+            return null;
+          }
+          if (needRunDocker) {
+            return dockerExec({
+              blocklet: nextBlocklet,
+              meta: b.meta,
+              script: b.meta.scripts?.[hookName],
+              hookName,
+              nodeInfo,
               env,
-              did, // root blocklet did,
-              teamManager: manager.teamManager,
               ...hookArgs,
             });
-          };
-
-        await startBlockletProcess(nextBlocklet, {
-          ...context,
-          preFlight: getHookFn('preFlight'),
-          preStart: getHookFn('preStart'),
-          postStart: getHookFn('postStart'),
-          nodeEnvironments,
-          nodeInfo,
-          e2eMode,
-          componentDids: item.componentDids,
-          configSynchronizer: manager.configSynchronizer,
-          isGreen: item.changeToGreen,
-        });
+          }
+          return hooks[hookName](b, {
+            appDir: b.env.appDir,
+            hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+            env,
+            did, // root blocklet did,
+            teamManager: manager.teamManager,
+            ...hookArgs,
+          });
+        };
 
-        // 健康检查绿色环境
-        const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(nextBlocklet, {
-          checkHealthImmediately,
-          componentDids: item.componentDids,
-        });
+      await startBlockletProcess(nextBlocklet, {
+        ...context,
+        preFlight: getHookFn('preFlight'),
+        preStart: getHookFn('preStart'),
+        postStart: getHookFn('postStart'),
+        nodeEnvironments,
+        nodeInfo,
+        e2eMode,
+        componentDids: item.componentDids,
+        configSynchronizer: manager.configSynchronizer,
+        isGreen: item.changeToGreen,
+      });
 
-        await manager._onCheckIfStarted(
-          {
-            did,
-            context,
-            minConsecutiveTime,
-            timeout: startTimeout,
-            componentDids: item.componentDids,
-          },
-          { throwOnError: true, isGreen: item.changeToGreen, needUpdateBlueStatus: true }
-        );
+      // 健康检查绿色环境
+      const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(nextBlocklet, {
+        checkHealthImmediately,
+        componentDids: item.componentDids,
+      });
 
-        logger.info('Green environment started successfully', {
+      await manager._onCheckIfStarted(
+        {
           did,
+          context,
+          minConsecutiveTime,
+          timeout: startTimeout,
           componentDids: item.componentDids,
-        });
-      } catch (err) {
-        const error = Array.isArray(err) ? err[0] : err;
-        logger.error('Failed to start green environment', { error, did, title: blocklet1.meta.title });
+        },
+        { throwOnError: true, isGreen: item.changeToGreen, needUpdateBlueStatus: true }
+      );
 
-        try {
-          await manager.deleteProcess({ did, componentDids: item.componentDids, isGreen: item.changeToGreen });
-          manager.emit(BlockletEvents.statusChange, blocklet1);
-        } catch (cleanupError) {
-          logger.error('Failed to cleanup green environment', { cleanupError });
-        }
+      logger.info('Green environment started successfully', {
+        did,
+        componentDids: item.componentDids,
+      });
+    } catch (err) {
+      const error = Array.isArray(err) ? err[0] : err;
+      logger.error('Failed to start green environment', { error, did, title: blocklet1.meta.title });
 
-        const description = `Green environment start failed for ${getDisplayName(blocklet1)}: ${error.message}`;
-        if (!ignoreErrorNotification) {
-          manager._createNotification(did, {
-            title: 'Blue-Green Deployment: Green Start Failed',
-            description,
-            entityType: 'blocklet',
-            entityId: did,
-            severity: 'error',
-          });
-        }
+      try {
+        await manager.deleteProcess({ did, componentDids: item.componentDids, isGreen: item.changeToGreen });
+        manager.emit(BlockletEvents.statusChange, blocklet1);
+      } catch (cleanupError) {
+        logger.error('Failed to cleanup green environment', { cleanupError });
+      }
 
-        if (throwOnError) {
-          throw new Error(description);
-        }
-        throw error;
+      const description = `Green environment start failed for ${getDisplayName(blocklet1)}: ${error.message}`;
+      if (!ignoreErrorNotification) {
+        manager._createNotification(did, {
+          title: 'Blue-Green Deployment: Green Start Failed',
+          description,
+          entityType: 'blocklet',
+          entityId: did,
+          severity: 'error',
+        });
       }
-    })
-  );
+
+      if (throwOnError) {
+        throw new Error(description);
+      }
+      throw error;
+    }
+  }
+
+  const nextBlocklet = await manager.getBlocklet(did);
+  const componentsInfo = getComponentsInternalInfo(nextBlocklet);
+  manager.emit(BlockletInternalEvents.componentStarted, {
+    appDid: nextBlocklet.appDid,
+    components: componentsInfo,
+  });
+
+  manager.emit(BlockletEvents.statusChange, nextBlocklet);
 };
 
 module.exports = {