egos-transfer 0.2.10 → 0.2.12

package/dist/connection-manager.d.ts

@@ -15,6 +15,8 @@ export interface ConnectionManagerDeps {
  */
 export declare class ConnectionManager {
     private pool;
+    /** peerId → 连接入池时间戳 */
+    private createdAt;
     private healthCheckTimer;
     private pingRequests;
     private destroyed;

package/dist/connection-manager.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionManager = void 0;
 const HEALTH_CHECK_INTERVAL = 15000;
+/** 连接最大存活时间：超过 15 分钟的连接在 get 时自动丢弃，强制重建 */
+const MAX_CONNECTION_AGE = 15 * 60 * 1000;
 /**
  * DataConnection 连接池管理器
  * - 管理 DataConnection 的生命周期（注册/移除/有效性检查）
@@ -20,6 +22,8 @@ const HEALTH_CHECK_INTERVAL = 15000;
 class ConnectionManager {
     constructor(deps) {
         this.pool = new Map();
+        /** peerId → 连接入池时间戳 */
+        this.createdAt = new Map();
         this.healthCheckTimer = null;
         this.pingRequests = new Map();
         this.destroyed = false;
@@ -61,6 +65,7 @@ class ConnectionManager {
      */
     setup(conn, onData) {
         this.pool.set(conn.peer, conn);
+        this.createdAt.set(conn.peer, Date.now());
         conn.on('data', onData);
         conn.on('close', () => this.handleConnClosed(conn));
         conn.on('error', () => this.handleConnClosed(conn));
@@ -87,6 +92,7 @@ class ConnectionManager {
             if (connectionId && conn.connectionId !== connectionId)
                 return;
             this.pool.delete(peerId);
+            this.createdAt.delete(peerId);
             // 先 close 触发 close 事件（handleConnClosed 会结算 in-flight 请求），
             // 再清理监听器与 PeerJS 内部引用，避免僵尸连接堆积导致无法建立新连接
             conn.close();
@@ -204,6 +210,7 @@ class ConnectionManager {
             this.remove(peerId);
         }
         this.pool.clear();
+        this.createdAt.clear();
         this.pingRequests.clear();
     }
 }

package/dist/peer-transfer.d.ts

@@ -31,6 +31,12 @@ export declare abstract class PeerTransfer {
     private idleTimer;
     /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
     private heartbeatTimer;
+    /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
+    private creatingPeer;
+    /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
+    private lastPeerCreatedAt;
+    /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
+    private createEpoch;
     constructor(deviceId: string, config: PeerTransferOptions);
     abstract getStore(): any;
     abstract online(deviceId: string): void;
@@ -43,6 +49,7 @@ export declare abstract class PeerTransfer {
     abstract onConnectLimit(): void;
     abstract reloadConfig(config?: Record<string, any>): Promise<void>;
     createPeer(force?: boolean): Promise<Peer>;
+    private doCreatePeer;
     private waitForOpen;
     handleSocketMessage(message: IMessage): void;
     connectToPeer(peerId: string): Promise<DataConnection | undefined>;
@@ -89,6 +96,8 @@ export declare abstract class PeerTransfer {
      * 与 destroy   stop 后仍可调用 createPeer 恢复工作。
      */
     stop(): void;
+    /** 使进行中的 Peer 创建作废：旧创建在恢复点自行中止，并允许 createPeer 立即重启 */
+    private abortCreate;
     private destroyPeer;
     askReload(peerId: string): void;
 }

package/dist/peer-transfer.js

@@ -27,6 +27,10 @@ const IDLE_RECREATE_TIMEOUT = 30 * 60 * 1000;
 /** 30 秒未收到服务端 HEARTBEAT 则重连 */
 const HEARTBEAT_TIMEOUT = 30000;
 exports.PEER_CLOSE_RECONNECT_TIMEOUT = 3000;
+/** Peer 创建节流窗口：窗口内禁止重复重建，防止事件风暴导致连续 create */
+const PEER_RECREATE_THROTTLE = 5000;
+/** 进行中的创建因 stop/clearInstance/新一轮创建而被中止时抛出的错误 */
+const PEER_CREATION_ABORTED = 'peer creation aborted';
 class PeerTransfer {
     constructor(deviceId, config) {
         this.requests = new Map();
@@ -42,6 +46,12 @@ class PeerTransfer {
         this.idleTimer = null;
         /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
         this.heartbeatTimer = null;
+        /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
+        this.creatingPeer = null;
+        /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
+        this.lastPeerCreatedAt = 0;
+        /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
+        this.createEpoch = 0;
         this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
         this.peerId = deviceId;
         this.deviceId = deviceId;
@@ -57,15 +67,50 @@ class PeerTransfer {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             this._exited = false;
+            // 并发去重：同一时刻只允许一次创建，后续调用复用进行中的 Promise
+            if (this.creatingPeer) {
+                return this.creatingPeer;
+            }
             if (((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) && !force) {
                 return this.peer;
             }
+            // 节流：距离上次创建尝试不足窗口期时直接返回现有实例，防止失败后热循环重建（force 可穿透）
+            if (!force && Date.now() - this.lastPeerCreatedAt < PEER_RECREATE_THROTTLE) {
+                return this.peer;
+            }
             console.info('create peer', Date.now());
+            const createPromise = this.doCreatePeer();
+            this.creatingPeer = createPromise;
+            try {
+                return yield createPromise;
+            }
+            finally {
+                // 仅当未被新一轮创建/abort 覆盖时才清理，避免误清新创建的引用
+                if (this.creatingPeer === createPromise) {
+                    this.creatingPeer = null;
+                }
+            }
+        });
+    }
+    doCreatePeer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const epoch = ++this.createEpoch; // 本轮创建的代际号
+            const isStale = () => epoch !== this.createEpoch;
+            this.lastPeerCreatedAt = Date.now(); // 记录创建尝试时间，节流窗口从尝试时刻起算
             this.destroyPeer();
             yield this.reloadConfig();
+            // reloadConfig 期间可能发生 stop()/destroy()，旧创建作废
+            if (isStale()) {
+                throw new Error(PEER_CREATION_ABORTED);
+            }
             const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 9000 }));
             this.peer = peer;
             yield this.waitForOpen(peer);
+            // waitForOpen 期间可能发生 stop()/destroy()，旧创建作废
+            if (isStale()) {
+                peer.destroy();
+                throw new Error(PEER_CREATION_ABORTED);
+            }
             this.destroyed = false;
             peer.on('close', () => {
                 // 仅当 Peer 非主动销毁（stop/clearInstance/重建）时才重连
@@ -539,6 +584,7 @@ class PeerTransfer {
     }
     clearInstance() {
         this.destroyed = true;
+        this.abortCreate();
         this.clearIdleTimer();
         this.clearHeartbeatTimer();
         this.connectionManager.destroy();
@@ -556,6 +602,7 @@ class PeerTransfer {
      */
     stop() {
         this._exited = true;
+        this.abortCreate();
         this.clearIdleTimer();
         this.clearHeartbeatTimer();
         this.connectionManager.stopHealthCheck();
@@ -565,6 +612,12 @@ class PeerTransfer {
         this.destroyPeer();
         this.reconnectAttempt = 0;
     }
+    /** 使进行中的 Peer 创建作废：旧创建在恢复点自行中止，并允许 createPeer 立即重启 */
+    abortCreate() {
+        this.createEpoch++; // 旧创建的 isStale() 变为 true，自行 destroy 并抛错
+        this.creatingPeer = null;
+        this.lastPeerCreatedAt = 0; // 重置节流，createPeer 可立即再次创建
+    }
     destroyPeer() {
         var _a, _b;
         (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egos-transfer",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "1234",
   "homepage": "https://github.com/superbogy/peer-transfer#readme",
   "bugs": {

package/src/connection-manager.ts

@@ -1,11 +1,10 @@
 import { DataConnection, Peer } from 'peerjs';
-import { PeerAction, PeerRoutes, PeerScope } from './entity';
-
-import { PING_TIMEOUT } from './constant';
 
 type ResponseCb = (args: any) => void;
 
 const HEALTH_CHECK_INTERVAL = 15000;
+/** 连接最大存活时间：超过 15 分钟的连接在 get 时自动丢弃，强制重建 */
+const MAX_CONNECTION_AGE = 15 * 60 * 1000;
 
 export interface ConnectionManagerDeps {
   /** 获取当前 Peer 实例（PeerTransfer 可能异步重建） */
@@ -74,7 +73,11 @@ export class ConnectionManager {
    * @param conn - 已打开的 DataConnection
    * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
    */
-  setup(conn: DataConnection, onData: (message: any) => void): DataConnection {
+  setup(
+    conn: DataConnection & { timestamp?: number },
+    onData: (message: any) => void,
+  ): DataConnection {
+    conn.timestamp = Date.now();
     this.pool.set(conn.peer, conn);
     conn.on('data', onData);
     conn.on('close', () => this.handleConnClosed(conn));
@@ -120,9 +123,14 @@ export class ConnectionManager {
     }
   }
 
-  isValid(conn?: DataConnection): boolean {
-    if (!conn?.open) return false;
-    if (!conn?.peerConnection) return false;
+  isValid(conn?: DataConnection & { timestamp?: number }): boolean {
+    if (!conn?.open || !conn?.peerConnection) {
+      return false;
+    }
+    // 检查连接是否过期
+    if (conn.timestamp && Date.now() - conn.timestamp > MAX_CONNECTION_AGE) {
+      return false;
+    }
     return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
   }
 

package/src/peer-transfer.ts

@@ -41,6 +41,10 @@ const IDLE_RECREATE_TIMEOUT = 30 * 60 * 1000;
 const HEARTBEAT_TIMEOUT = 30000;
 
 export const PEER_CLOSE_RECONNECT_TIMEOUT = 3000;
+/** Peer 创建节流窗口：窗口内禁止重复重建，防止事件风暴导致连续 create */
+const PEER_RECREATE_THROTTLE = 5000;
+/** 进行中的创建因 stop/clearInstance/新一轮创建而被中止时抛出的错误 */
+const PEER_CREATION_ABORTED = 'peer creation aborted';
 
 export abstract class PeerTransfer {
   protected peer: Peer | undefined;
@@ -62,6 +66,12 @@ export abstract class PeerTransfer {
   private idleTimer: ReturnType<typeof setTimeout> | null = null;
   /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
   private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
+  /** 进行中的 Peer 创建：并发调用复用同一个 Promise，防止交叉 destroy/新建 */
+  private creatingPeer: Promise<Peer> | null = null;
+  /** 上次成功创建 Peer 的时间戳：节流窗口内直接复用现有实例 */
+  private lastPeerCreatedAt = 0;
+  /** 创建代际：stop/clearInstance/新一轮创建时递增，使旧的进行中创建作废 */
+  private createEpoch = 0;
 
   constructor(deviceId: string, config: PeerTransferOptions) {
     this.peerConfig = { ...config, key: String(Date.now()) };
@@ -90,17 +100,51 @@ export abstract class PeerTransfer {
 
   async createPeer(force?: boolean): Promise<Peer> {
     this._exited = false;
+    // 并发去重：同一时刻只允许一次创建，后续调用复用进行中的 Promise
+    if (this.creatingPeer) {
+      return this.creatingPeer;
+    }
     if (this.peer?.open && !force) {
       return this.peer;
     }
+    // 节流：距离上次创建尝试不足窗口期时直接返回现有实例，防止失败后热循环重建（force 可穿透）
+    if (!force && Date.now() - this.lastPeerCreatedAt < PEER_RECREATE_THROTTLE) {
+      return this.peer!;
+    }
     console.info('create peer', Date.now());
+    const createPromise = this.doCreatePeer();
+    this.creatingPeer = createPromise;
+    try {
+      return await createPromise;
+    } finally {
+      // 仅当未被新一轮创建/abort 覆盖时才清理，避免误清新创建的引用
+      if (this.creatingPeer === createPromise) {
+        this.creatingPeer = null;
+      }
+    }
+  }
+
+  private async doCreatePeer(): Promise<Peer> {
+    const epoch = ++this.createEpoch; // 本轮创建的代际号
+    const isStale = () => epoch !== this.createEpoch;
+    this.lastPeerCreatedAt = Date.now(); // 记录创建尝试时间，节流窗口从尝试时刻起算
     this.destroyPeer();
     await this.reloadConfig();
 
+    // reloadConfig 期间可能发生 stop()/destroy()，旧创建作废
+    if (isStale()) {
+      throw new Error(PEER_CREATION_ABORTED);
+    }
+
     const peer = new Peer(this.peerId, { ...this.peerConfig, pingInterval: 9000 });
     this.peer = peer;
 
     await this.waitForOpen(peer);
+    // waitForOpen 期间可能发生 stop()/destroy()，旧创建作废
+    if (isStale()) {
+      peer.destroy();
+      throw new Error(PEER_CREATION_ABORTED);
+    }
     this.destroyed = false;
     peer.on('close', () => {
       // 仅当 Peer 非主动销毁（stop/clearInstance/重建）时才重连
@@ -641,6 +685,7 @@ export abstract class PeerTransfer {
 
   clearInstance() {
     this.destroyed = true;
+    this.abortCreate();
     this.clearIdleTimer();
     this.clearHeartbeatTimer();
 
@@ -662,6 +707,7 @@ export abstract class PeerTransfer {
    */
   stop() {
     this._exited = true;
+    this.abortCreate();
     this.clearIdleTimer();
     this.clearHeartbeatTimer();
     this.connectionManager.stopHealthCheck();
@@ -672,6 +718,13 @@ export abstract class PeerTransfer {
     this.reconnectAttempt = 0;
   }
 
+  /** 使进行中的 Peer 创建作废：旧创建在恢复点自行中止，并允许 createPeer 立即重启 */
+  private abortCreate() {
+    this.createEpoch++; // 旧创建的 isStale() 变为 true，自行 destroy 并抛错
+    this.creatingPeer = null;
+    this.lastPeerCreatedAt = 0; // 重置节流，createPeer 可立即再次创建
+  }
+
   private destroyPeer() {
     this.peer?.destroy();
     this.peer?.removeAllListeners();