egos-transfer 0.1.1 → 0.1.4

package/dist/constant.d.ts

@@ -2,7 +2,7 @@ export declare const REQUEST_TIMEOUT = 18000;
 export declare const HEARTBEAT_INTERVAL = 12000;
 export declare const TRANSFER_TIMEOUT = 300000;
 export declare const PING_TIMEOUT = 5000;
-export declare const CONNECTION_TIMEOUT = 6000;
+export declare const CONNECTION_TIMEOUT = 12000;
 export declare const LOCKER_TIMEOUT = 15000;
 export declare const RECONNECT_TIMEOUT = 5000;
 export declare const PEER_OPEN_TIMEOUT = 15000;

package/dist/constant.js

@@ -5,7 +5,7 @@ exports.REQUEST_TIMEOUT = 18000;
 exports.HEARTBEAT_INTERVAL = 12000;
 exports.TRANSFER_TIMEOUT = 300000;
 exports.PING_TIMEOUT = 5000;
-exports.CONNECTION_TIMEOUT = 6000;
+exports.CONNECTION_TIMEOUT = 12000;
 exports.LOCKER_TIMEOUT = 15000;
 exports.RECONNECT_TIMEOUT = 5000;
 exports.PEER_OPEN_TIMEOUT = 15000;

package/dist/file-transfer.js

@@ -302,6 +302,7 @@ class FileTransfer {
             }
             if (processed.length === totalChunk) {
                 const checksum = yield this.taskService.verifyFile(task.transId);
+                console.log('file verify', checksum);
                 if (checksum) {
                     yield this.done(task);
                     yield this.updateTask(task.transId, {

package/dist/index.d.ts

@@ -7,6 +7,9 @@ export interface ContentPayload {
     parent: string;
 }
 type ResponseCb<T = any> = (args: T) => void;
+type PeerTransferOptions = PeerOptions & {
+    turnExpiredAt: number;
+};
 export declare abstract class PeerTransfer {
     protected peer: Peer | undefined;
     protected peerPool: Map<string, Peer>;
@@ -18,7 +21,7 @@ export declare abstract class PeerTransfer {
         reject: (reason?: any) => void;
     }>;
     protected retry: number;
-    protected peerConfig: PeerOptions | undefined;
+    protected peerConfig: PeerTransferOptions | undefined;
     deviceId: string;
     protected requests: Map<string, ResponseCb>;
     protected timeout: number;
@@ -28,7 +31,7 @@ export declare abstract class PeerTransfer {
     protected checkerId: ReturnType<typeof setInterval>;
     isPaused: boolean;
     peerId: string;
-    constructor(deviceId: string, config: PeerOptions, isRadomPeerId?: boolean);
+    constructor(deviceId: string, config: PeerTransferOptions, isRadomPeerId?: boolean);
     abstract getStore(): any;
     abstract online(deviceId: string): void;
     abstract offline(deviceId: string): void;
@@ -38,6 +41,7 @@ export declare abstract class PeerTransfer {
     abstract onDestroy(): void;
     abstract requireAuth(): Promise<void>;
     abstract onConnectLimit(): void;
+    abstract reloadConfig(config?: Record<string, any>): Promise<void>;
     initialize(peer: Peer): Promise<string>;
     handleSocketMessage(message: IMessage): void;
     onHeartbeat(message: IMessage): void;
@@ -51,6 +55,7 @@ export declare abstract class PeerTransfer {
     getApiHost(): string;
     getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined>;
     connectToPeer(deviceId: string): Promise<DataConnection | undefined>;
+    private createConnection;
     ping(peerId: string): Promise<boolean>;
     onConnect(conn: DataConnection): Promise<DataConnection | undefined>;
     request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage>;

package/dist/index.js

@@ -215,6 +215,12 @@ class PeerTransfer {
             if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
                 yield this.reconnect();
             }
+            // turn credential expires
+            if (this.peerConfig.turnExpiredAt && Date.now() - 30000 > this.peerConfig.turnExpiredAt) {
+                yield this.createPeer(true);
+                this.connectPool.clear();
+                return;
+            }
             const deviceIds = this.connectPool.keys();
             for (const deviceId of deviceIds) {
                 const conn = this.connectPool.get(deviceId);
@@ -264,69 +270,63 @@ class PeerTransfer {
                 peerId = status.deviceId;
                 this.peerIdMap.set(pdId, peerId);
             }
-            if (this.connectPool.has(peerId)) {
-                const conn = this.connectPool.get(peerId);
-                if (conn === null || conn === void 0 ? void 0 : conn.open) {
-                    return conn;
-                }
+            const existingConn = this.connectPool.get(peerId);
+            if (existingConn === null || existingConn === void 0 ? void 0 : existingConn.open) {
+                return existingConn;
             }
-            // Check if there's already a connection attempt for this peerId
             if (PeerTransfer.connecting.has(peerId)) {
-                // Wait for the existing connection attempt to complete
-                const { promise } = yield PeerTransfer.connecting.get(peerId);
-                return yield promise;
+                const entry = PeerTransfer.connecting.get(peerId);
+                const conn = yield (entry === null || entry === void 0 ? void 0 : entry.promise);
+                if (conn) {
+                    return conn;
+                }
             }
-            // Create a new connection promise and store it in connecting map
-            let resolve, reject;
+            return this.createConnection(peerId);
+        });
+    }
+    createConnection(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            let resolve;
+            let reject;
             const connectionPromise = new Promise((res, rej) => {
                 resolve = res;
                 reject = rej;
             });
-            // Store the promise in connecting map
             PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
-            const buildConnFn = () => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                try {
-                    let retry = 0;
-                    while (retry < 3) {
-                        if (!this.peer) {
-                            yield this.createPeer();
-                        }
-                        if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
-                            yield this.reconnect();
-                        }
-                        const cur = this.connectPool.get(peerId);
-                        if (cur === null || cur === void 0 ? void 0 : cur.open) {
-                            this.online(peerId);
-                            resolve(cur);
-                            return cur;
-                        }
-                        const conn = (_b = this.peer) === null || _b === void 0 ? void 0 : _b.connect(peerId, { reliable: true });
-                        if (!conn) {
-                            retry++;
-                            continue;
-                        }
-                        const connection = yield this.onConnect(conn).catch((err) => { });
-                        if (connection) {
-                            this.online(peerId);
-                            return resolve(conn);
-                        }
-                        retry++;
+            try {
+                for (let retry = 0; retry < 3; retry++) {
+                    if (!this.peer) {
+                        yield this.createPeer();
+                    }
+                    if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
+                        yield this.reconnect();
+                    }
+                    const cur = this.connectPool.get(peerId);
+                    if (cur === null || cur === void 0 ? void 0 : cur.open) {
+                        resolve(cur);
+                        return cur;
+                    }
+                    const conn = (_b = this.peer) === null || _b === void 0 ? void 0 : _b.connect(peerId);
+                    if (!conn) {
+                        continue;
+                    }
+                    const connection = yield this.onConnect(conn).catch(() => { });
+                    if (connection) {
+                        resolve(conn);
+                        return conn;
                     }
-                    resolve(null);
-                }
-                catch (err) {
-                    reject(err);
-                }
-                finally {
-                    // Remove from connecting map regardless of success or failure
-                    PeerTransfer.connecting.delete(peerId);
                 }
-            });
-            buildConnFn();
-            // Wait for the connection to complete
-            const conn = yield connectionPromise;
-            return conn;
+                resolve(undefined);
+                return undefined;
+            }
+            catch (err) {
+                reject(err);
+                throw err;
+            }
+            finally {
+                PeerTransfer.connecting.delete(peerId);
+            }
         });
     }
     ping(peerId) {
@@ -379,8 +379,10 @@ class PeerTransfer {
                 conn.on('data', (message) => {
                     switch (message.scope) {
                         case entity_1.PeerScope.REQUEST:
+                            // console.log('peer@onRequest', message.route);
                             return this.onRequest(conn, message);
                         case entity_1.PeerScope.RESPONSE:
+                            // console.log('peer@onResponse', message.route);
                             return this.onResponse(conn, message);
                         default:
                             return this.responseFail(conn, message, 'unknown scope');
@@ -412,6 +414,7 @@ class PeerTransfer {
     request(peerId, payload) {
         return __awaiter(this, void 0, void 0, function* () {
             const conn = yield this.connectToPeer(peerId);
+            // console.log('connected@peerId', peerId, payload.route);
             if (!conn) {
                 return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'build connection failed', code: -1 } });
             }
@@ -499,7 +502,7 @@ class PeerTransfer {
                 if ((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) {
                     return this.peer;
                 }
-                console.log('reconnecting~~', Date.now());
+                console.log('peer reconnecting....', Date.now());
                 if ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.disconnected) {
                     this.peer.reconnect();
                     return;
@@ -535,6 +538,7 @@ class PeerTransfer {
                 return this.peer;
             }
             this.destroy();
+            yield this.reloadConfig();
             const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 15000 }));
             this.peer = peer;
             if (this.checkerId) {

package/package.json

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

package/src/constant.ts

@@ -2,7 +2,7 @@ export const REQUEST_TIMEOUT = 18000;
 export const HEARTBEAT_INTERVAL = 12000;
 export const TRANSFER_TIMEOUT = 300000;
 export const PING_TIMEOUT = 5000;
-export const CONNECTION_TIMEOUT = 6000;
+export const CONNECTION_TIMEOUT = 12000;
 export const LOCKER_TIMEOUT = 15000;
 export const RECONNECT_TIMEOUT = 5000;
 export const PEER_OPEN_TIMEOUT = 15000;

package/src/file-transfer.ts

@@ -346,6 +346,7 @@ export class FileTransfer {
     }
     if (processed.length === totalChunk) {
       const checksum = await this.taskService.verifyFile(task.transId);
+      console.log('file verify', checksum);
       if (checksum) {
         await this.done(task);
         await this.updateTask(task.transId, {

package/src/index.ts

@@ -30,6 +30,9 @@ export interface ContentPayload {
 }
 
 type ResponseCb<T = any> = (args: T) => void;
+type PeerTransferOptions = PeerOptions & {
+  turnExpiredAt: number; // date time ms
+};
 
 export abstract class PeerTransfer {
   protected peer: Peer | undefined;
@@ -49,7 +52,7 @@ export abstract class PeerTransfer {
 
   protected retry = 0;
 
-  protected peerConfig: PeerOptions | undefined;
+  protected peerConfig: PeerTransferOptions | undefined;
   public deviceId: string;
   protected requests: Map<string, ResponseCb>;
   protected timeout: number;
@@ -60,7 +63,7 @@ export abstract class PeerTransfer {
   public isPaused: boolean;
   peerId: string;
 
-  constructor(deviceId: string, config: PeerOptions, isRadomPeerId = false) {
+  constructor(deviceId: string, config: PeerTransferOptions, isRadomPeerId = false) {
     this.connectPool = new Map<string, DataConnection>();
     this.peerConfig = {
       ...config,
@@ -84,6 +87,7 @@ export abstract class PeerTransfer {
   abstract onDestroy(): void;
   abstract requireAuth(): Promise<void>;
   abstract onConnectLimit(): void;
+  abstract reloadConfig(config?: Record<string, any>): Promise<void>;
   async initialize(peer: Peer) {
     try {
       this.booted = new Promise((resolve) => {
@@ -252,6 +256,12 @@ export abstract class PeerTransfer {
       if (!this.peer?.open) {
         await this.reconnect();
       }
+      // turn credential expires
+      if (this.peerConfig.turnExpiredAt && Date.now() - 30000 > this.peerConfig.turnExpiredAt) {
+        await this.createPeer(true);
+        this.connectPool.clear();
+        return;
+      }
       const deviceIds = this.connectPool.keys();
       for (const deviceId of deviceIds) {
         const conn = this.connectPool.get(deviceId);
@@ -285,8 +295,10 @@ export abstract class PeerTransfer {
     if (deviceId === this.deviceId) {
       return;
     }
+
     let peerId = deviceId;
     const pdId = purifyDeviceId(deviceId);
+
     if (this.peerIdMap.has(pdId)) {
       peerId = this.peerIdMap.get(pdId) || '';
     } else {
@@ -297,68 +309,68 @@ export abstract class PeerTransfer {
       peerId = status.deviceId;
       this.peerIdMap.set(pdId, peerId);
     }
-    if (this.connectPool.has(peerId)) {
-      const conn = this.connectPool.get(peerId);
-      if (conn?.open) {
-        return conn;
-      }
+
+    const existingConn = this.connectPool.get(peerId);
+    if (existingConn?.open) {
+      return existingConn;
     }
-    // Check if there's already a connection attempt for this peerId
+
     if (PeerTransfer.connecting.has(peerId)) {
-      // Wait for the existing connection attempt to complete
-      const { promise } = await PeerTransfer.connecting.get(peerId);
-      return await promise;
+      const entry = PeerTransfer.connecting.get(peerId);
+      const conn = await entry?.promise;
+      if (conn) {
+        return conn;
+      }
     }
 
-    // Create a new connection promise and store it in connecting map
-    let resolve, reject;
+    return this.createConnection(peerId);
+  }
+
+  private async createConnection(peerId: string): Promise<DataConnection | undefined> {
+    let resolve!: (value: DataConnection | undefined) => void;
+    let reject!: (reason?: any) => void;
+
     const connectionPromise = new Promise<DataConnection | undefined>((res, rej) => {
       resolve = res;
       reject = rej;
     });
-    // Store the promise in connecting map
+
     PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
-    const buildConnFn = async () => {
-      try {
-        let retry = 0;
-        while (retry < 3) {
-          if (!this.peer) {
-            await this.createPeer();
-          }
-          if (!this.peer?.open) {
-            await this.reconnect();
-          }
-          const cur = this.connectPool.get(peerId);
-          if (cur?.open) {
-            this.online(peerId);
-            resolve(cur);
-            return cur;
-          }
-          const conn = this.peer?.connect(peerId, { reliable: true });
-          if (!conn) {
-            retry++;
-            continue;
-          }
-          const connection = await this.onConnect(conn as DataConnection).catch((err) => {});
-          if (connection) {
-            this.online(peerId);
-            return resolve(conn);
-          }
-          retry++;
+
+    try {
+      for (let retry = 0; retry < 3; retry++) {
+        if (!this.peer) {
+          await this.createPeer();
+        }
+        if (!this.peer?.open) {
+          await this.reconnect();
         }
-        resolve(null);
-      } catch (err) {
-        reject(err);
-      } finally {
-        // Remove from connecting map regardless of success or failure
-        PeerTransfer.connecting.delete(peerId);
-      }
-    };
 
-    buildConnFn();
-    // Wait for the connection to complete
-    const conn = await connectionPromise;
-    return conn;
+        const cur = this.connectPool.get(peerId);
+        if (cur?.open) {
+          resolve(cur);
+          return cur;
+        }
+
+        const conn = this.peer?.connect(peerId);
+        if (!conn) {
+          continue;
+        }
+
+        const connection = await this.onConnect(conn as DataConnection).catch(() => {});
+        if (connection) {
+          resolve(conn);
+          return conn;
+        }
+      }
+      resolve(undefined);
+      return undefined;
+    } catch (err) {
+      reject(err);
+      throw err;
+    } finally {
+      PeerTransfer.connecting.delete(peerId);
+    }
   }
 
   async ping(peerId: string) {
@@ -408,8 +420,10 @@ export abstract class PeerTransfer {
       conn.on('data', (message: any) => {
         switch (message.scope) {
           case PeerScope.REQUEST:
+            // console.log('peer@onRequest', message.route);
             return this.onRequest(conn, message);
           case PeerScope.RESPONSE:
+            // console.log('peer@onResponse', message.route);
             return this.onResponse(conn, message);
           default:
             return this.responseFail(conn, message, 'unknown scope');
@@ -438,6 +452,7 @@ export abstract class PeerTransfer {
 
   async request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage> {
     const conn = await this.connectToPeer(peerId);
+    // console.log('connected@peerId', peerId, payload.route);
     if (!conn) {
       return {
         ...payload,
@@ -560,7 +575,7 @@ export abstract class PeerTransfer {
       if (this.peer?.open) {
         return this.peer;
       }
-      console.log('reconnecting~~', Date.now());
+      console.log('peer reconnecting....', Date.now());
       if (this.peer?.disconnected) {
         this.peer.reconnect();
         return;
@@ -594,6 +609,7 @@ export abstract class PeerTransfer {
     }
 
     this.destroy();
+    await this.reloadConfig();
     const peer = new Peer(this.peerId, {
       ...this.peerConfig,
       pingInterval: 15000,