egos-transfer 0.1.3 → 0.1.4

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

@@ -55,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

@@ -270,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) {
@@ -385,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');
@@ -418,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 } });
             }
@@ -505,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;

package/package.json

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

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

@@ -295,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 {
@@ -307,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) {
@@ -418,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');
@@ -448,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,
@@ -570,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;