egos-transfer 0.1.3 → 0.1.6

package/dist/index.js

@@ -32,100 +32,112 @@ const peerjs_1 = require("peerjs");
 const entity_1 = require("./entity");
 const router_1 = require("./router");
 const axios_1 = __importDefault(require("axios"));
-const helper_1 = require("./helper");
 class PeerTransfer {
     constructor(deviceId, config, isRadomPeerId = false) {
-        this.peerIdMap = new Map();
         this.retry = 0;
+        this.inRequest = new Map();
         this.connectPool = new Map();
         this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
         this.requests = new Map();
         this.timeout = entity_1.REQUEST_TIMEOUT;
         this.router = new router_1.PeerRouter();
-        this.peerPool = new Map();
         this.isPaused = false;
         this.peerId = isRadomPeerId ? deviceId + '_' + Date.now() : deviceId;
         this.deviceId = deviceId;
     }
+    createPeer() {
+        return __awaiter(this, arguments, void 0, function* (force = false) {
+            var _a;
+            if (this.isPaused) {
+                return;
+            }
+            if (this.booted) {
+                return this.booted;
+            }
+            if (((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) && !force) {
+                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;
+            yield this.initialize(this.peer);
+            this.checkConnection();
+            return this.peer;
+        });
+    }
     initialize(peer) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                if (this.checkerId) {
+                    clearInterval(this.checkerId);
+                }
                 this.booted = new Promise((resolve) => {
                     const timer = setTimeout(() => {
-                        var _a;
-                        if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
-                            this.createPeer(true);
-                        }
-                        // reject('peer open timeout');
+                        resolve(null);
                     }, constant_1.PEER_OPEN_TIMEOUT);
+                    const done = (peer) => {
+                        clearTimeout(timer);
+                        resolve(peer);
+                    };
                     peer.on('open', (id) => {
-                        this.booted = undefined;
                         clearTimeout(timer);
-                        resolve(id);
+                        done(peer);
                     });
+                    peer.on('disconnected', () => {
+                        if (!this.isPaused) {
+                            setTimeout(() => {
+                                if (!this.isPaused) {
+                                    this.reconnect();
+                                }
+                            }, constant_1.CONNECTION_RETRY);
+                        }
+                    });
+                    // duplicated with close event
+                    peer.on('close', (...args) => { });
+                    peer.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
+                        if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
+                            this.stop();
+                            done(null);
+                            return;
+                        }
+                        if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
+                            this.stop();
+                            this.onConnectLimit();
+                            return done(null);
+                        }
+                        if (err.message == constant_1.UNAUTHORIZED) {
+                            done(null);
+                            return this.requireAuth();
+                        }
+                        if (err.type === 'network') {
+                            done(null);
+                            return this.reconnect();
+                        }
+                        if (err.type === 'server-error') {
+                            done(null);
+                            return this.reconnect();
+                        }
+                        done(null);
+                        return this.reconnect();
+                    }));
                 });
                 peer.on('connection', (conn) => {
+                    conn.label = 'incoming';
                     this.onConnect(conn);
                 });
-                peer.on('disconnected', () => {
-                    if (!this.isPaused) {
-                        setTimeout(() => {
-                            if (!this.isPaused) {
-                                this.reconnect();
-                            }
-                        }, constant_1.CONNECTION_RETRY);
-                    }
-                });
-                peer.on('call', (mConn) => { });
-                peer.on('close', (...args) => {
-                    if (this.isPaused) {
-                        return;
-                    }
-                    setTimeout(() => {
-                        this.reconnect();
-                    }, constant_1.CONNECTION_RETRY);
-                });
-                peer.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
-                    if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
-                        this.stop();
-                    }
-                    if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
-                        this.stop();
-                        this.onConnectLimit();
-                    }
-                    if (err.message == constant_1.UNAUTHORIZED) {
-                        yield this.requireAuth();
-                    }
-                    if (err.type === 'network') {
-                        this.reconnect();
-                    }
-                    if (err.type === 'server-error') {
-                        if (err.message === constant_1.UNAUTHORIZED) {
-                            yield this.requireAuth();
-                        }
-                        else {
-                            this.reconnect();
-                        }
-                    }
-                }));
                 const socket = peer.socket;
                 socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
                     this.handleSocketMessage(message);
                 });
-                socket === null || socket === void 0 ? void 0 : socket.on('error', (err) => {
-                    console.log('socket@error', err);
-                });
-                socket.on('close', () => {
-                    console.log('socket@close');
-                    setTimeout(() => {
-                        this.reconnect();
-                    }, constant_1.CONNECTION_RETRY);
-                });
                 this.onHeartbeat({ type: 'HEARTBEAT' });
-                return this.booted;
+                yield this.booted;
             }
             catch (err) {
-                console.log('peer client initialize error', err);
+                this.booted = undefined;
+            }
+            finally {
+                this.booted = undefined;
             }
         });
     }
@@ -164,7 +176,6 @@ class PeerTransfer {
             });
             return;
         }
-        this.reconnect();
     }
     onOpen(message) {
         if (message.type !== 'OPEN') {
@@ -185,21 +196,29 @@ class PeerTransfer {
             return;
         }
         const deviceId = message.payload.deviceId;
-        this.offline(deviceId);
         this.ping(deviceId);
     }
-    removeConnection(peerId) {
-        var _a, _b;
+    removeConnection(peerId, connectionId) {
+        var _a;
         const conn = this.connectPool.get(peerId);
         if (conn) {
-            if ((_a = conn.metadata) === null || _a === void 0 ? void 0 : _a.intervalId) {
-                clearInterval((_b = conn.metadata) === null || _b === void 0 ? void 0 : _b.intervalId);
+            if (connectionId && conn.connectionId !== connectionId) {
+                return;
+            }
+            const sending = this.inRequest.get(conn.connectionId);
+            if (sending) {
+                // 提前结束request，避免关闭连接时触发反馈
+                sending.feedback();
+                this.inRequest.delete(conn.connectionId);
             }
             this.connectPool.delete(peerId);
-            this.offline(peerId);
+            conn.removeAllListeners();
+            conn.close();
+            (_a = this.peer) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
         }
     }
     addConnection(conn) {
+        // console.log('addConnection@', conn.label);
         this.connectPool.set(conn.peer, conn);
         const connecting = PeerTransfer.connecting.get(conn.peer);
         if (connecting) {
@@ -217,17 +236,20 @@ class PeerTransfer {
             }
             // turn credential expires
             if (this.peerConfig.turnExpiredAt && Date.now() - 30000 > this.peerConfig.turnExpiredAt) {
+                // this.connectPool.clear();
                 yield this.createPeer(true);
-                this.connectPool.clear();
                 return;
             }
-            const deviceIds = this.connectPool.keys();
-            for (const deviceId of deviceIds) {
-                const conn = this.connectPool.get(deviceId);
-                if (conn) {
-                    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);
+            //     this.peer?._removeConnection(conn);
+            //   } else {
+            //     this.ping(conn.peer);
+            //   }
+            // }
         }), constant_1.HEARTBEAT_INTERVAL);
     }
     getApiHost() {
@@ -257,82 +279,72 @@ class PeerTransfer {
             if (deviceId === this.deviceId) {
                 return;
             }
-            let peerId = deviceId;
-            const pdId = (0, helper_1.purifyDeviceId)(deviceId);
-            if (this.peerIdMap.has(pdId)) {
-                peerId = this.peerIdMap.get(pdId) || '';
-            }
-            else {
-                const status = yield this.getDeviceStatus(deviceId);
-                if (!status || !status.isOnline) {
-                    return;
+            const peerId = deviceId;
+            const existingConn = this.connectPool.get(peerId);
+            // console.log('connectToPeer', peerId, existingConn, this.connectPool);
+            if (existingConn) {
+                if (this.isValidConnection(existingConn)) {
+                    return existingConn;
                 }
-                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;
+                else {
+                    this.removeConnection(peerId);
                 }
             }
-            // 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 (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;
                     }
-                    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);
+            }
+            finally {
+                PeerTransfer.connecting.delete(peerId);
+            }
         });
     }
     ping(peerId) {
@@ -341,7 +353,8 @@ class PeerTransfer {
                 return;
             }
             const conn = this.connectPool.get(peerId);
-            if (!conn) {
+            if (!this.isValidConnection(conn)) {
+                this.removeConnection(conn === null || conn === void 0 ? void 0 : conn.peer);
                 return;
             }
             const res = yield this.request(conn.peer, {
@@ -362,6 +375,19 @@ class PeerTransfer {
             if (!conn) {
                 return;
             }
+            const exists = this.connectPool.get(conn.peer);
+            // console.log('onConnect', conn.label, exists);
+            if (exists) {
+                if (exists.metadata.time > conn.metadata.time) {
+                    this.removeConnection(conn.peer);
+                    if (this.isValidConnection(exists)) {
+                        return exists;
+                    }
+                }
+                else {
+                    this.removeConnection(exists.peer);
+                }
+            }
             return new Promise((resolve) => {
                 const done = (connection) => {
                     if (connection) {
@@ -371,14 +397,13 @@ class PeerTransfer {
                     resolve(connection);
                 };
                 const timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    if (conn.open) {
+                    if (this.isValidConnection(conn)) {
                         this.addConnection(conn);
                         done(conn);
                     }
                     else {
                         conn.close();
                         this.removeConnection(conn.peer);
-                        yield this.createPeer();
                         done(undefined);
                     }
                 }), constant_1.CONNECTION_TIMEOUT);
@@ -394,31 +419,34 @@ class PeerTransfer {
                 });
                 conn.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
-                    this.removeConnection(conn.peer);
+                    this.removeConnection(conn.peer, conn.connectionId);
                     if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
                         yield this.reconnect();
                     }
+                    done(null);
                 }));
                 conn.on('close', () => __awaiter(this, void 0, void 0, function* () {
                     var _a;
-                    this.removeConnection(conn.peer);
+                    this.removeConnection(conn.peer, conn.connectionId);
                     if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
                         yield this.reconnect();
                     }
+                    done(null);
                 }));
                 conn.on('open', () => __awaiter(this, void 0, void 0, function* () {
-                    this.addConnection(conn);
                     clearTimeout(timer);
                     done(conn);
                 }));
-                // }
+                if (this.isValidConnection(conn)) {
+                    done(conn);
+                }
             });
         });
     }
     request(peerId, payload) {
         return __awaiter(this, void 0, void 0, function* () {
             const conn = yield this.connectToPeer(peerId);
-            if (!conn) {
+            if (!this.isValidConnection(conn)) {
                 return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'build connection failed', code: -1 } });
             }
             const requestId = payload.requestId || (yield this.genRequestId());
@@ -428,15 +456,24 @@ class PeerTransfer {
                         body: {},
                         error: { message: 'request timeout' },
                     };
-                    this.removeConnection(peerId);
+                    this.removeConnection(conn.peer);
                     resolve(msg);
                 }, payload.timeout || entity_1.REQUEST_TIMEOUT);
+                this.inRequest.set(conn.connectionId, {
+                    conn,
+                    message: payload,
+                    feedback: () => resolve({
+                        body: {},
+                        error: { message: 'send failed' },
+                    }),
+                });
                 this.addRequest(requestId, (message) => {
                     clearTimeout(timeout);
                     const now = Date.now();
                     if (now - message.createdAt > 3000) {
                         console.warn('[egos] slow peer request:', message.route, now - message.createdAt);
                     }
+                    this.inRequest.delete(conn.connectionId);
                     resolve(message);
                 });
             });
@@ -448,7 +485,7 @@ class PeerTransfer {
     reply(conn, oldMessage, message) {
         return __awaiter(this, void 0, void 0, function* () {
             const data = Object.assign(Object.assign(Object.assign({}, this.inheritMessage(oldMessage)), message), { dest: conn.peer, scope: entity_1.PeerScope.RESPONSE, updatedAt: Date.now() });
-            if (!conn.open) {
+            if (!this.isValidConnection(conn)) {
                 const connection = yield this.connectToPeer(conn.peer);
                 return connection === null || connection === void 0 ? void 0 : connection.send(data);
             }
@@ -459,7 +496,7 @@ class PeerTransfer {
         return __awaiter(this, void 0, void 0, function* () {
             const internalApi = yield this.getApi(conn.peer);
             let connection = conn;
-            if (!conn.open) {
+            if (!this.isValidConnection) {
                 const con = yield this.connectToPeer(conn.peer);
                 if (!con) {
                     return this.responseFail(conn, message, 'send with invalid connection');
@@ -495,27 +532,32 @@ class PeerTransfer {
             });
         });
     }
+    isValidConnection(conn) {
+        if (!(conn === null || conn === void 0 ? void 0 : conn.open)) {
+            return false;
+        }
+        if (!(conn === null || conn === void 0 ? void 0 : conn.peerConnection)) {
+            return false;
+        }
+        return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+    }
     doReconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             try {
                 if (this.isPaused) {
                     return;
                 }
-                if ((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) {
+                if (((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) && this.peerConfig.token === ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.options.token)) {
                     return this.peer;
                 }
-                console.log('reconnecting~~', Date.now());
-                if ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.disconnected) {
+                // return this.createPeer();
+                if (((_c = this.peer) === null || _c === void 0 ? void 0 : _c.disconnected) && ((_d = this.peer) === null || _d === void 0 ? void 0 : _d.options.token) === this.peerConfig.token) {
                     this.peer.reconnect();
-                    return;
+                    return this.peer;
                 }
                 else {
-                    yield new Promise((resolve) => {
-                        setTimeout(() => {
-                            resolve(undefined);
-                        }, constant_1.RECONNECT_TIMEOUT);
-                    });
+                    yield this.reloadConfig();
                     return this.createPeer();
                 }
             }
@@ -524,34 +566,6 @@ class PeerTransfer {
             }
         });
     }
-    createPeer() {
-        return __awaiter(this, arguments, void 0, function* (force = false) {
-            var _a, _b;
-            if (this.isPaused) {
-                return;
-            }
-            if (this.booted) {
-                yield this.booted;
-                if ((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open) {
-                    return this.peer;
-                }
-                this.booted = undefined;
-            }
-            if (((_b = this.peer) === null || _b === void 0 ? void 0 : _b.open) && !force) {
-                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) {
-                clearInterval(this.checkerId);
-            }
-            this.checkConnection();
-            yield this.initialize(peer);
-            return this.peer;
-        });
-    }
     clearInstance() {
         var _a, _b;
         PeerTransfer.connecting.clear();
@@ -560,8 +574,7 @@ class PeerTransfer {
             this.removeConnection(pId);
         }
         (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();
-        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.disconnect();
-        this.peerPool.clear();
+        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
         this.booted = undefined;
         this.peer = undefined;
         if (this.checkerId) {

package/dist/router.js

@@ -118,7 +118,7 @@ class PeerRouter {
                     .sort((a, b) => (b.priority || 0) - (a.priority || 0));
                 const res = yield this.compose(stack)(conn, message);
                 // Execute route handler with timeout
-                const routePromise = Promise.resolve(route.callback.apply(this, [conn, message]));
+                const routePromise = Promise.resolve(route.callback.apply(null, [conn, message]));
                 const timeoutPromise = new Promise((_, reject) => {
                     setTimeout(() => reject(new Error('Request timeout')), route.timeout || 30000);
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egos-transfer",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "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 = 12000;
+export const CONNECTION_TIMEOUT = 6000;
 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, {