egos-transfer 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -42,7 +42,7 @@ export declare abstract class PeerTransfer {
     abstract onConnectLimit(): void;
     abstract reloadConfig(config?: Record<string, any>): Promise<void>;
     createPeer(force?: boolean): Promise<Peer | undefined>;
-    initialize(peer: Peer): Promise<void>;
+    initialize(peer: Peer): Promise<Peer>;
     handleSocketMessage(message: IMessage): void;
     onHeartbeat(message: IMessage): void;
     onError(message: IMessage): void;

package/dist/index.js

@@ -59,7 +59,7 @@ class PeerTransfer {
             }
             this.destroy();
             yield this.reloadConfig();
-            const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 15000 }));
+            const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 9000 }));
             this.peer = peer;
             yield this.initialize(this.peer);
             this.checkConnection();
@@ -72,6 +72,9 @@ class PeerTransfer {
                 if (this.checkerId) {
                     clearInterval(this.checkerId);
                 }
+                if (this.booted) {
+                    return this.booted;
+                }
                 this.booted = new Promise((resolve) => {
                     const timer = setTimeout(() => {
                         resolve(null);
@@ -119,7 +122,7 @@ class PeerTransfer {
                             return this.reconnect();
                         }
                         done(null);
-                        return this.reconnect();
+                        return this.createPeer(true);
                     }));
                 });
                 peer.on('connection', (conn) => {
@@ -227,7 +230,7 @@ class PeerTransfer {
     }
     checkConnection() {
         if (this.checkerId) {
-            return;
+            clearInterval(this.checkerId);
         }
         this.checkerId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -235,21 +238,22 @@ class PeerTransfer {
                 yield this.reconnect();
             }
             // turn credential expires
-            if (this.peerConfig.turnExpiredAt && Date.now() - 30000 > this.peerConfig.turnExpiredAt) {
+            if (this.peerConfig.turnExpiredAt && this.peerConfig.turnExpiredAt - 30000 < Date.now()) {
                 // this.connectPool.clear();
+                yield this.reloadConfig();
                 yield this.createPeer(true);
                 return;
             }
-            // const deviceIds = this.connectPool.keys();
-            // for (const deviceId of deviceIds) {
-            //   const conn = this.connectPool.get(deviceId);
-            //   if (!this.isValidConnection(conn)) {
-            //     this.removeConnection(conn.peer);
-            //     this.peer?._removeConnection(conn);
-            //   } else {
-            //     this.ping(conn.peer);
-            //   }
-            // }
+            const deviceIds = this.connectPool.keys();
+            for (const deviceId of deviceIds) {
+                const conn = this.connectPool.get(deviceId);
+                if (!this.isValidConnection(conn)) {
+                    this.removeConnection(conn.peer);
+                }
+                else {
+                    // this.ping(conn.peer);
+                }
+            }
         }), constant_1.HEARTBEAT_INTERVAL);
     }
     getApiHost() {
@@ -281,7 +285,7 @@ class PeerTransfer {
             }
             const peerId = deviceId;
             const existingConn = this.connectPool.get(peerId);
-            // console.log('connectToPeer', peerId, existingConn, this.connectPool);
+            console.log('connectToPeer', existingConn === null || existingConn === void 0 ? void 0 : existingConn.open, this.connectPool.size);
             if (existingConn) {
                 if (this.isValidConnection(existingConn)) {
                     return existingConn;
@@ -302,49 +306,56 @@ class PeerTransfer {
     }
     createConnection(peerId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
             let resolve;
             let reject;
+            const q = PeerTransfer.connecting.get(peerId);
+            if (q) {
+                return q.promise;
+            }
             const connectionPromise = new Promise((res, rej) => {
                 resolve = res;
                 reject = rej;
             });
             PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
-            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 (this.isValidConnection(cur)) {
-                        resolve(cur);
-                        return cur;
-                    }
-                    const conn = (_b = this.peer) === null || _b === void 0 ? void 0 : _b.connect(peerId, {
-                        label: 'outgoing',
-                        metadata: { time: Date.now() },
-                    });
-                    if (!conn) {
-                        continue;
-                    }
-                    const connection = yield this.onConnect(conn).catch(() => { });
-                    if (connection) {
-                        resolve(conn);
-                        return conn;
+            const doConnect = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                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 (this.isValidConnection(cur)) {
+                            return resolve(cur);
+                        }
+                        const conn = (_b = this.peer) === null || _b === void 0 ? void 0 : _b.connect(peerId, {
+                            label: 'outgoing',
+                            metadata: { time: Date.now() },
+                        });
+                        if (!conn) {
+                            continue;
+                        }
+                        const connection = yield this.onConnect(conn).catch(() => { });
+                        if (connection) {
+                            return resolve(connection);
+                        }
                     }
+                    resolve(undefined);
+                    return undefined;
                 }
-                resolve(undefined);
-                return undefined;
-            }
-            catch (err) {
-                reject(err);
-            }
-            finally {
-                PeerTransfer.connecting.delete(peerId);
-            }
+                catch (err) {
+                    reject(err);
+                }
+                finally {
+                    PeerTransfer.connecting.delete(peerId);
+                }
+            });
+            doConnect();
+            const conn = yield connectionPromise;
+            return conn;
         });
     }
     ping(peerId) {

package/package.json

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

package/src/index.ts

@@ -101,7 +101,7 @@ export abstract class PeerTransfer {
     await this.reloadConfig();
     const peer = new Peer(this.peerId, {
       ...this.peerConfig,
-      pingInterval: 15000,
+      pingInterval: 9000,
     });
     this.peer = peer;
     await this.initialize(this.peer);
@@ -114,6 +114,10 @@ export abstract class PeerTransfer {
         clearInterval(this.checkerId);
       }
 
+      if (this.booted) {
+        return this.booted;
+      }
+
       this.booted = new Promise((resolve) => {
         const timer = setTimeout(() => {
           resolve(null);
@@ -161,7 +165,7 @@ export abstract class PeerTransfer {
             return this.reconnect();
           }
           done(null);
-          return this.reconnect();
+          return this.createPeer(true);
         });
       });
       peer.on('connection', (conn: DataConnection) => {
@@ -272,28 +276,28 @@ export abstract class PeerTransfer {
 
   checkConnection() {
     if (this.checkerId) {
-      return;
+      clearInterval(this.checkerId);
     }
     this.checkerId = setInterval(async () => {
       if (!this.peer?.open) {
         await this.reconnect();
       }
       // turn credential expires
-      if (this.peerConfig.turnExpiredAt && Date.now() - 30000 > this.peerConfig.turnExpiredAt) {
+      if (this.peerConfig.turnExpiredAt && this.peerConfig.turnExpiredAt - 30000 < Date.now()) {
         // this.connectPool.clear();
+        await this.reloadConfig();
         await this.createPeer(true);
         return;
       }
-      // const deviceIds = this.connectPool.keys();
-      // for (const deviceId of deviceIds) {
-      //   const conn = this.connectPool.get(deviceId);
-      //   if (!this.isValidConnection(conn)) {
-      //     this.removeConnection(conn.peer);
-      //     this.peer?._removeConnection(conn);
-      //   } else {
-      //     this.ping(conn.peer);
-      //   }
-      // }
+      const deviceIds = this.connectPool.keys();
+      for (const deviceId of deviceIds) {
+        const conn = this.connectPool.get(deviceId);
+        if (!this.isValidConnection(conn)) {
+          this.removeConnection(conn.peer);
+        } else {
+          // this.ping(conn.peer);
+        }
+      }
     }, HEARTBEAT_INTERVAL);
   }
 
@@ -323,7 +327,7 @@ export abstract class PeerTransfer {
 
     const peerId = deviceId;
     const existingConn = this.connectPool.get(peerId);
-    // console.log('connectToPeer', peerId, existingConn, this.connectPool);
+    console.log('connectToPeer', existingConn?.open, this.connectPool.size);
     if (existingConn) {
       if (this.isValidConnection(existingConn)) {
         return existingConn;
@@ -346,48 +350,54 @@ export abstract class PeerTransfer {
   private async createConnection(peerId: string): Promise<DataConnection | undefined> {
     let resolve!: (value: DataConnection | undefined) => void;
     let reject!: (reason?: any) => void;
-
+    const q = PeerTransfer.connecting.get(peerId);
+    if (q) {
+      return q.promise;
+    }
     const connectionPromise = new Promise<DataConnection | undefined>((res, rej) => {
       resolve = res;
       reject = rej;
     });
 
     PeerTransfer.connecting.set(peerId, { promise: connectionPromise, resolve, reject });
-    try {
-      for (let retry = 0; retry < 3; retry++) {
-        if (!this.peer) {
-          await this.createPeer();
-        }
-        if (!this.peer?.open) {
-          await this.reconnect();
-        }
+    const doConnect = async () => {
+      try {
+        for (let retry = 0; retry < 3; retry++) {
+          if (!this.peer) {
+            await this.createPeer();
+          }
+          if (!this.peer?.open) {
+            await this.reconnect();
+          }
 
-        const cur = this.connectPool.get(peerId);
-        if (this.isValidConnection(cur)) {
-          resolve(cur);
-          return cur;
-        }
+          const cur = this.connectPool.get(peerId);
+          if (this.isValidConnection(cur)) {
+            return resolve(cur);
+          }
 
-        const conn = this.peer?.connect(peerId, {
-          label: 'outgoing',
-          metadata: { time: Date.now() },
-        });
-        if (!conn) {
-          continue;
-        }
-        const connection = await this.onConnect(conn as DataConnection).catch(() => {});
-        if (connection) {
-          resolve(conn);
-          return conn;
+          const conn = this.peer?.connect(peerId, {
+            label: 'outgoing',
+            metadata: { time: Date.now() },
+          });
+          if (!conn) {
+            continue;
+          }
+          const connection = await this.onConnect(conn as DataConnection).catch(() => {});
+          if (connection) {
+            return resolve(connection);
+          }
         }
+        resolve(undefined);
+        return undefined;
+      } catch (err) {
+        reject(err);
+      } finally {
+        PeerTransfer.connecting.delete(peerId);
       }
-      resolve(undefined);
-      return undefined;
-    } catch (err) {
-      reject(err);
-    } finally {
-      PeerTransfer.connecting.delete(peerId);
-    }
+    };
+    doConnect();
+    const conn = await connectionPromise;
+    return conn;
   }
 
   async ping(peerId: string) {