egos-transfer 0.2.6 → 0.2.7

package/dist/peer-transfer.js

@@ -0,0 +1,565 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerTransfer = exports.PEER_CLOSE_RECONNECT_TIMEOUT = void 0;
+const constant_1 = require("./constant");
+const peerjs_1 = require("peerjs");
+const entity_1 = require("./entity");
+const connection_manager_1 = require("./connection-manager");
+const router_1 = require("./router");
+const axios_1 = __importDefault(require("axios"));
+const delay_1 = __importDefault(require("delay"));
+const MAX_RECONNECT_BACKOFF = 30000;
+const BASE_RECONNECT_BACKOFF = 1000;
+/** 30 分钟无消息活动则重建 Peer，防止长时间空闲后 signaling 连接僵死 */
+const IDLE_RECREATE_TIMEOUT = 30 * 60 * 1000;
+/** 30 秒未收到服务端 HEARTBEAT 则重连 */
+const HEARTBEAT_TIMEOUT = 30000;
+exports.PEER_CLOSE_RECONNECT_TIMEOUT = 3000;
+class PeerTransfer {
+    constructor(deviceId, config) {
+        this.requests = new Map();
+        this.router = new router_1.PeerRouter();
+        this.reconnectAttempt = 0;
+        this.destroyed = false;
+        /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
+        this.connRequests = new Map();
+        this._reconnecting = false;
+        /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
+        this._exited = false;
+        /** 空闲重连定时器：超时无消息活动则重建 Peer */
+        this.idleTimer = null;
+        /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
+        this.heartbeatTimer = null;
+        this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
+        this.peerId = deviceId;
+        this.deviceId = deviceId;
+        this.connectionManager = new connection_manager_1.ConnectionManager({
+            getPeer: () => this.peer,
+            peerId: this.peerId,
+            onConnClosed: (conn) => this.onConnClosed(conn),
+            ping: (peerId) => this.ping(peerId),
+        });
+    }
+    // ── Peer lifecycle ──────────────────────────────────────────────
+    createPeer(force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            console.info('createPeer##', (_a = this.peer) === null || _a === void 0 ? void 0 : _a.open, force);
+            this._exited = false;
+            if (((_b = this.peer) === null || _b === void 0 ? void 0 : _b.open) && !force) {
+                return this.peer;
+            }
+            this.destroyPeer();
+            yield this.reloadConfig();
+            const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 9000 }));
+            this.peer = peer;
+            yield this.waitForOpen(peer);
+            this.destroyed = false;
+            peer.on('close', () => {
+                setTimeout(() => this.destroyed && this.reconnect(), exports.PEER_CLOSE_RECONNECT_TIMEOUT);
+            });
+            peer.on('error', (err) => {
+                // 覆盖所有与 signaling server 断连相关的错误类型
+                if (err.type === 'network' ||
+                    err.type === 'server-error' ||
+                    err.type === 'disconnected' ||
+                    err.type === 'socket-error' ||
+                    err.type === 'socket-closed') {
+                    this.reconnect();
+                }
+            });
+            peer.on('connection', (conn) => {
+                conn.label = 'incoming';
+                this.onConnect(conn);
+            });
+            const socket = peer.socket;
+            socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
+                this.handleSocketMessage(message);
+            });
+            // 启动连接健康检查
+            this.connectionManager.startHealthCheck();
+            // 启动空闲重连定时器
+            this.resetIdleTimer();
+            // 启动心跳超时定时器
+            this.resetHeartbeatTimer();
+            return peer;
+        });
+    }
+    waitForOpen(peer) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(), constant_1.PEER_OPEN_TIMEOUT);
+            peer.on('open', () => {
+                clearTimeout(timer);
+                this.reconnectAttempt = 0;
+                resolve();
+            });
+            peer.once('error', (err) => {
+                if (err.message === constant_1.CONNECTION_DUPLICATED) {
+                    clearTimeout(timer);
+                    // signaling server 仍持有旧连接，主动 destroy 以清理服务端状态
+                    peer.destroy();
+                    resolve();
+                    return;
+                }
+                clearTimeout(timer);
+                if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
+                    resolve();
+                    return;
+                }
+                if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
+                    this.onConnectLimit();
+                    resolve();
+                    return;
+                }
+                if (err.message === constant_1.UNAUTHORIZED) {
+                    this.requireAuth();
+                    resolve();
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    handleSocketMessage(message) {
+        var _a;
+        switch (message.type) {
+            case 'ONLINE':
+                this.online(message.payload.deviceId);
+                break;
+            case 'OFFLINE':
+                this.ping(message.payload.deviceId);
+                break;
+            case 'HEARTBEAT':
+                this.resetHeartbeatTimer();
+                break;
+            case 'ERROR':
+                if (((_a = message.payload) === null || _a === void 0 ? void 0 : _a.msg) === constant_1.CONNECTION_PEER_CONFLICT) {
+                    this.getStore().dispatch({
+                        type: 'global/updateNetworkState',
+                        payload: { error: true, code: 'PEER_CONNECTION_CONFLICT', message: 'peer conflict' },
+                    });
+                }
+                break;
+        }
+    }
+    // ── Connection management ───────────────────────────────────────
+    connectToPeer(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (peerId === this.deviceId)
+                return;
+            const existing = this.connectionManager.get(peerId);
+            if (existing) {
+                return existing;
+            }
+            return this.createConnection(peerId);
+        });
+    }
+    createConnection(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            for (let retry = 0; retry < 3; retry++) {
+                if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
+                    try {
+                        yield this.createPeer();
+                    }
+                    catch (_c) {
+                        /* fall through */
+                    }
+                }
+                if (!((_b = this.peer) === null || _b === void 0 ? void 0 : _b.open))
+                    continue;
+                const pooled = this.connectionManager.get(peerId);
+                if (pooled) {
+                    return pooled;
+                }
+                const conn = this.peer.connect(peerId, {
+                    label: 'outgoing',
+                    metadata: { time: Date.now() },
+                });
+                if (!conn)
+                    continue;
+                const result = yield this.onConnect(conn).catch(() => undefined);
+                if (result) {
+                    return result;
+                }
+                const pooled2 = this.connectionManager.get(peerId);
+                if (pooled2) {
+                    return pooled2;
+                }
+            }
+            // 所有重试均失败，强制销毁 peer 以确保下次连接使用全新实例
+            // (peer.open 可能在 signaling socket 已断连的情况下仍返回 true)
+            if (!this.destroyed) {
+                this.destroyPeer();
+            }
+            return undefined;
+        });
+    }
+    onConnect(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!conn)
+                return;
+            if (conn.open) {
+                this.setupConnection(conn);
+                return conn;
+            }
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    conn.off('open', onOpen);
+                    conn.off('error', onError);
+                    conn.off('close', onClose);
+                    resolve(this.isValidConnection(conn) ? this.setupConnection(conn) : undefined);
+                }, constant_1.CONNECTION_TIMEOUT);
+                const onOpen = () => {
+                    clearTimeout(timer);
+                    resolve(this.setupConnection(conn));
+                };
+                const onError = () => {
+                    clearTimeout(timer);
+                    const pooled = this.connectionManager.get(conn.peer);
+                    resolve(pooled);
+                };
+                const onClose = () => {
+                    clearTimeout(timer);
+                    resolve(undefined);
+                    this.removeConnection(conn.peer, conn.connectionId);
+                };
+                conn.once('open', onOpen);
+                conn.once('error', onError);
+                conn.once('close', onClose);
+            });
+        });
+    }
+    setupConnection(conn) {
+        return this.connectionManager.setup(conn, (message) => {
+            switch (message.scope) {
+                case entity_1.PeerScope.REQUEST:
+                    return this.onRequest(conn, message);
+                case entity_1.PeerScope.RESPONSE:
+                    return this.onResponse(conn, message);
+                default:
+                    return this.responseFail(conn, message, 'unknown scope');
+            }
+        });
+    }
+    onConnClosed(conn) {
+        const reqIds = this.connRequests.get(conn.connectionId);
+        if (reqIds) {
+            // for (const reqId of reqIds) {
+            //   const cb = this.requests.get(reqId);
+            //   if (cb) {
+            //     cb({ error: { message: 'connection closed', code: 'CONN_CLOSED' } } as any);
+            //     this.requests.delete(reqId);
+            //   }
+            // }
+            this.connRequests.delete(conn.connectionId);
+        }
+    }
+    removeConnection(peerId, connectionId) {
+        this.connectionManager.remove(peerId, connectionId);
+    }
+    isValidConnection(conn) {
+        return this.connectionManager.isValid(conn);
+    }
+    // ── Request / Reply ─────────────────────────────────────────────
+    request(peerId, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const requestId = payload.requestId || (yield this.genRequestId());
+            let res;
+            for (let attempt = 0; attempt <= 2; payload.route, attempt++) {
+                res = yield this.doRequestOnce(peerId, payload, requestId);
+                const code = (_a = res.error) === null || _a === void 0 ? void 0 : _a.code;
+                if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED')) {
+                    return res;
+                }
+            }
+            return res;
+        });
+    }
+    doRequestOnce(peerId, payload, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.destroyed) {
+                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'destroyed', code: 'CONN_CLOSED' } });
+            }
+            const conn = yield this.connectToPeer(peerId);
+            if (!this.isValidConnection(conn)) {
+                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'connection failed', code: 'CONN_FAILED' } });
+            }
+            return new Promise((resolve) => {
+                let timeout = null;
+                const cleanup = () => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                        timeout = null;
+                    }
+                    this.requests.delete(requestId);
+                    const reqs = this.connRequests.get(conn.connectionId);
+                    if (reqs) {
+                        reqs.delete(requestId);
+                        // connection pool cleanup
+                        if (reqs.size === 0) {
+                            this.connRequests.delete(conn.connectionId);
+                        }
+                    }
+                };
+                timeout = setTimeout(() => {
+                    cleanup();
+                    if (!this.isValidConnection(conn)) {
+                        this.removeConnection(conn.peer, conn.connectionId);
+                    }
+                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'timeout', code: 'TIMEOUT' } }));
+                }, payload.timeout || entity_1.REQUEST_TIMEOUT);
+                let reqs = this.connRequests.get(conn.connectionId);
+                if (!reqs) {
+                    reqs = new Set();
+                    this.connRequests.set(conn.connectionId, reqs);
+                }
+                reqs.add(requestId);
+                this.requests.set(requestId, (message) => {
+                    cleanup();
+                    resolve(message);
+                });
+                this.send(conn, Object.assign(Object.assign({}, payload), { requestId })).catch(() => {
+                    cleanup();
+                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
+                });
+            });
+        });
+    }
+    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 (!this.isValidConnection(conn)) {
+                const c = yield this.connectToPeer(conn.peer);
+                return c === null || c === void 0 ? void 0 : c.send(data);
+            }
+            return conn.send(data);
+        });
+    }
+    send(conn, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const internalApi = yield this.getApi(conn.peer);
+            let connection = conn;
+            if (!this.isValidConnection(conn)) {
+                const c = yield this.connectToPeer(conn.peer);
+                if (!c)
+                    return this.responseFail(conn, message, 'send with invalid connection');
+                connection = c;
+            }
+            const requestId = message.requestId || (yield this.genRequestId());
+            return connection.send(Object.assign(Object.assign({}, message), { requestId, headers: Object.assign(Object.assign({}, message.headers), { ['x-device-token']: internalApi === null || internalApi === void 0 ? void 0 : internalApi.token }), scope: entity_1.PeerScope.REQUEST, action: entity_1.PeerAction.SEND, src: this.peerId, dest: conn.peer, createdAt: Date.now() }), false);
+        });
+    }
+    // ── Ping ────────────────────────────────────────────────────────
+    ping(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceId === peerId) {
+                return false;
+            }
+            const conn = this.connectionManager.get(peerId);
+            if (!conn) {
+                return false;
+            }
+            try {
+                const requestId = yield this.genRequestId();
+                return new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        this.requests.delete(requestId);
+                        resolve(false);
+                    }, constant_1.PING_TIMEOUT);
+                    this.requests.set(requestId, () => {
+                        clearTimeout(timer);
+                        resolve(true);
+                    });
+                    conn.send({
+                        route: entity_1.PeerRoutes.HEARTBEAT,
+                        method: 'get',
+                        body: {},
+                        requestId,
+                        scope: entity_1.PeerScope.REQUEST,
+                        action: entity_1.PeerAction.SEND,
+                        src: this.peerId,
+                        dest: peerId,
+                        headers: {},
+                        createdAt: Date.now(),
+                    });
+                });
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    // ── Server helpers ──────────────────────────────────────────────
+    getApiHost() {
+        var _a, _b, _c;
+        const protocol = ((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.secure) ? 'https' : 'http';
+        const host = ((_b = this.peerConfig) === null || _b === void 0 ? void 0 : _b.host) || 'localhost';
+        const port = ((_c = this.peerConfig) === null || _c === void 0 ? void 0 : _c.port) || 9000;
+        return `${protocol}://${host}:${port}`;
+    }
+    getDeviceStatus(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield axios_1.default.get(`${this.getApiHost()}/api/v1/devices/${peerId}/status`);
+                if (res.status < 400)
+                    return res.data.data;
+            }
+            catch (_a) {
+                /* ignore */
+            }
+        });
+    }
+    // ── Reconnection ────────────────────────────────────────────────
+    reconnect(force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._reconnecting || this._exited)
+                return;
+            this._reconnecting = true;
+            try {
+                this.reconnectAttempt++;
+                const backoff = Math.min(BASE_RECONNECT_BACKOFF * Math.pow(2, this.reconnectAttempt - 1), MAX_RECONNECT_BACKOFF);
+                yield (0, delay_1.default)(backoff);
+                yield this.reloadConfig();
+                return yield this.createPeer(force);
+            }
+            catch (_a) {
+                return this.createPeer(force);
+            }
+            finally {
+                this._reconnecting = false;
+            }
+        });
+    }
+    // ── Message helpers ─────────────────────────────────────────────
+    inheritMessage(receiveMsg) {
+        return {
+            src: this.peerId,
+            id: receiveMsg.id,
+            requestId: receiveMsg.requestId,
+            route: receiveMsg.route,
+            createdAt: receiveMsg.createdAt,
+            action: entity_1.PeerAction.RECEIVE,
+        };
+    }
+    // ── Router integration ──────────────────────────────────────────
+    onRequest(conn, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resetIdleTimer();
+            try {
+                yield this.router.run(conn, message);
+            }
+            catch (err) {
+                this.responseFail(conn, message, { message: err.message, code: err.code });
+            }
+        });
+    }
+    onResponse(_conn, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resetIdleTimer();
+            // 优先检查 health check ping 回调
+            const cb = this.requests.get(message.requestId);
+            if (cb) {
+                cb.apply(this, [message]);
+                this.requests.delete(message.requestId);
+            }
+        });
+    }
+    responseOk(conn, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.reply(conn, message, { body: { ok: true } });
+        });
+    }
+    responseFail(conn, message, err) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.reply(conn, message, { body: {}, error: err || 'service error' });
+        });
+    }
+    use(handler, prefix = '') {
+        this.router.use(handler, prefix);
+    }
+    addRoute(route) {
+        this.router.add(route);
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────
+    resetIdleTimer() {
+        if (this.idleTimer !== null) {
+            clearTimeout(this.idleTimer);
+        }
+        this.idleTimer = setTimeout(() => {
+            if (!this.destroyed) {
+                this.reconnect(true);
+            }
+        }, IDLE_RECREATE_TIMEOUT);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer !== null) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+    resetHeartbeatTimer() {
+        if (this.heartbeatTimer !== null) {
+            clearTimeout(this.heartbeatTimer);
+        }
+        this.heartbeatTimer = setTimeout(() => {
+            if (!this.destroyed) {
+                this.reconnect(true);
+            }
+        }, HEARTBEAT_TIMEOUT);
+    }
+    clearHeartbeatTimer() {
+        if (this.heartbeatTimer !== null) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    clearInstance() {
+        this.destroyed = true;
+        this.clearIdleTimer();
+        this.clearHeartbeatTimer();
+        this.connectionManager.destroy();
+        this.requests.clear();
+        this.connRequests.clear();
+        this.destroyPeer();
+    }
+    destroy() {
+        this.clearInstance();
+        this.onDestroy();
+    }
+    /**
+     * 退出：关闭 peer 和所有连接，停止自动重连。
+     * 与 destroy   stop 后仍可调用 createPeer 恢复工作。
+     */
+    stop() {
+        this._exited = true;
+        this.clearIdleTimer();
+        this.clearHeartbeatTimer();
+        this.connectionManager.stopHealthCheck();
+        this.connectionManager.clean();
+        this.requests.clear();
+        this.connRequests.clear();
+        this.destroyPeer();
+        this.reconnectAttempt = 0;
+    }
+    destroyPeer() {
+        var _a, _b;
+        (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
+        this.peer = undefined;
+    }
+}
+exports.PeerTransfer = PeerTransfer;

package/dist/server.d.ts

@@ -2,10 +2,6 @@ import { PeerMessage, RequestCallbackFn, RouteItem } from './interfaces';
 import { DataConnection } from 'peerjs';
 import { PeerRouter } from './router';
 import { PeerTransfer } from './index';
-export interface ContentPayload {
-    file: string;
-    parent: string;
-}
 type ResponseCb<T = any> = (args: T) => void;
 type SetupServerCB = () => Promise<PeerTransfer>;
 export declare class PeerServer {

package/package.json

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