peerpigeon 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +1187 -0
- package/examples/browser/app-dht-disabled.js +42 -0
- package/examples/browser/app.js +51 -0
- package/examples/browser/assets/images/favicon.png +0 -0
- package/examples/browser/assets/images/pigeon.png +0 -0
- package/examples/browser/index-dht-disabled.html +123 -0
- package/examples/browser/index.html +340 -0
- package/examples/browser/styles.css +1288 -0
- package/examples/browser/ui-clean.js +0 -0
- package/examples/browser/ui.js +1930 -0
- package/index.js +8 -0
- package/package.json +70 -0
- package/server/index.js +515 -0
- package/src/CleanupManager.js +181 -0
- package/src/ConnectionManager.js +841 -0
- package/src/EventEmitter.js +27 -0
- package/src/EvictionManager.js +257 -0
- package/src/GossipManager.js +416 -0
- package/src/MediaManager.js +225 -0
- package/src/MeshOptimizer.js +181 -0
- package/src/PeerConnection.js +831 -0
- package/src/PeerDiscovery.js +297 -0
- package/src/PeerPigeonMesh.js +703 -0
- package/src/SignalingClient.js +536 -0
- package/src/SignalingHandler.js +325 -0
- package/src/StorageManager.js +88 -0
- package/src/TimerUtils.js +46 -0
- package/src/WebDHT.js +1099 -0
- package/websocket-server/README.md +257 -0
- package/websocket-server/memory-leak-test.js +193 -0
- package/websocket-server/node_modules/.package-lock.json +29 -0
- package/websocket-server/node_modules/ws/LICENSE +20 -0
- package/websocket-server/node_modules/ws/README.md +548 -0
- package/websocket-server/node_modules/ws/browser.js +8 -0
- package/websocket-server/node_modules/ws/index.js +13 -0
- package/websocket-server/node_modules/ws/lib/buffer-util.js +131 -0
- package/websocket-server/node_modules/ws/lib/constants.js +18 -0
- package/websocket-server/node_modules/ws/lib/event-target.js +292 -0
- package/websocket-server/node_modules/ws/lib/extension.js +203 -0
- package/websocket-server/node_modules/ws/lib/limiter.js +55 -0
- package/websocket-server/node_modules/ws/lib/permessage-deflate.js +528 -0
- package/websocket-server/node_modules/ws/lib/receiver.js +706 -0
- package/websocket-server/node_modules/ws/lib/sender.js +602 -0
- package/websocket-server/node_modules/ws/lib/stream.js +161 -0
- package/websocket-server/node_modules/ws/lib/subprotocol.js +62 -0
- package/websocket-server/node_modules/ws/lib/validation.js +152 -0
- package/websocket-server/node_modules/ws/lib/websocket-server.js +550 -0
- package/websocket-server/node_modules/ws/lib/websocket.js +1388 -0
- package/websocket-server/node_modules/ws/package.json +69 -0
- package/websocket-server/node_modules/ws/wrapper.mjs +8 -0
- package/websocket-server/package-lock.json +39 -0
- package/websocket-server/server.js +298 -0
- package/websocket-server/test.js +133 -0
package/index.js
ADDED
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
// Main entry point for PeerPigeon npm package
|
|
2
|
+
export { PeerPigeonMesh } from './src/PeerPigeonMesh.js';
|
|
3
|
+
export { PeerConnection } from './src/PeerConnection.js';
|
|
4
|
+
export { SignalingClient } from './src/SignalingClient.js';
|
|
5
|
+
export { WebDHT } from './src/WebDHT.js';
|
|
6
|
+
|
|
7
|
+
// Export the WebSocket server class for programmatic use
|
|
8
|
+
export { PeerPigeonServer } from './server/index.js';
|
package/package.json
ADDED
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "peerpigeon",
|
|
3
|
+
"version": "0.0.1",
|
|
4
|
+
"description": "WebRTC-based peer-to-peer mesh networking library with intelligent routing and signaling server",
|
|
5
|
+
"main": "index.js",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"exports": {
|
|
8
|
+
".": {
|
|
9
|
+
"import": "./index.js"
|
|
10
|
+
}
|
|
11
|
+
},
|
|
12
|
+
"scripts": {
|
|
13
|
+
"dev": "http-server . -p 8080 -c-1",
|
|
14
|
+
"start": "node websocket-server/server.js",
|
|
15
|
+
"server": "node websocket-server/server.js",
|
|
16
|
+
"test": "echo 'No tests configured yet'",
|
|
17
|
+
"lint": "echo 'No linting configured yet'",
|
|
18
|
+
"prepublishOnly": "echo 'Ready for npm publish'"
|
|
19
|
+
},
|
|
20
|
+
"files": [
|
|
21
|
+
"index.js",
|
|
22
|
+
"src/",
|
|
23
|
+
"server/",
|
|
24
|
+
"websocket-server/",
|
|
25
|
+
"examples/",
|
|
26
|
+
"README.md",
|
|
27
|
+
"LICENSE"
|
|
28
|
+
],
|
|
29
|
+
"repository": {
|
|
30
|
+
"type": "git",
|
|
31
|
+
"url": "git+https://github.com/draeder/peerpigeon.git"
|
|
32
|
+
},
|
|
33
|
+
"keywords": [
|
|
34
|
+
"webrtc",
|
|
35
|
+
"p2p",
|
|
36
|
+
"mesh",
|
|
37
|
+
"networking",
|
|
38
|
+
"decentralized",
|
|
39
|
+
"kademlia",
|
|
40
|
+
"signaling",
|
|
41
|
+
"websocket",
|
|
42
|
+
"peer-to-peer",
|
|
43
|
+
"dht",
|
|
44
|
+
"gossip",
|
|
45
|
+
"mesh-network",
|
|
46
|
+
"xor-routing",
|
|
47
|
+
"webrtc-mesh"
|
|
48
|
+
],
|
|
49
|
+
"author": "Daniel Raeder",
|
|
50
|
+
"license": "MIT",
|
|
51
|
+
"bugs": {
|
|
52
|
+
"url": "https://github.com/draeder/peerpigeon/issues"
|
|
53
|
+
},
|
|
54
|
+
"homepage": "https://github.com/draeder/peerpigeon#readme",
|
|
55
|
+
"dependencies": {
|
|
56
|
+
"ws": "^8.18.0"
|
|
57
|
+
},
|
|
58
|
+
"devDependencies": {
|
|
59
|
+
"@koush/wrtc": "^0.5.3",
|
|
60
|
+
"http-server": "^14.1.1"
|
|
61
|
+
},
|
|
62
|
+
"engines": {
|
|
63
|
+
"node": ">=14.0.0"
|
|
64
|
+
},
|
|
65
|
+
"browserslist": [
|
|
66
|
+
"last 2 versions",
|
|
67
|
+
"not dead",
|
|
68
|
+
"> 1%"
|
|
69
|
+
]
|
|
70
|
+
}
|
package/server/index.js
ADDED
|
@@ -0,0 +1,515 @@
|
|
|
1
|
+
// PeerPigeon WebSocket Server - Node.js module
|
|
2
|
+
import { WebSocketServer } from 'ws';
|
|
3
|
+
import { createServer } from 'http';
|
|
4
|
+
import { EventEmitter } from 'events';
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* PeerPigeon WebSocket signaling server
|
|
8
|
+
* Can be used programmatically or as a standalone server
|
|
9
|
+
*/
|
|
10
|
+
export class PeerPigeonServer extends EventEmitter {
|
|
11
|
+
constructor(options = {}) {
|
|
12
|
+
super();
|
|
13
|
+
|
|
14
|
+
this.port = options.port || 3000;
|
|
15
|
+
this.host = options.host || 'localhost';
|
|
16
|
+
this.maxConnections = options.maxConnections || 1000;
|
|
17
|
+
this.cleanupInterval = options.cleanupInterval || 60000; // 1 minute
|
|
18
|
+
this.peerTimeout = options.peerTimeout || 300000; // 5 minutes
|
|
19
|
+
this.corsOrigin = options.corsOrigin || '*';
|
|
20
|
+
this.maxMessageSize = options.maxMessageSize || 1048576; // 1MB
|
|
21
|
+
|
|
22
|
+
this.httpServer = null;
|
|
23
|
+
this.wss = null;
|
|
24
|
+
this.connections = new Map(); // peerId -> WebSocket
|
|
25
|
+
this.peerData = new Map(); // peerId -> peer info
|
|
26
|
+
this.isRunning = false;
|
|
27
|
+
this.cleanupTimer = null;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
/**
|
|
31
|
+
* Start the WebSocket server
|
|
32
|
+
*/
|
|
33
|
+
async start() {
|
|
34
|
+
if (this.isRunning) {
|
|
35
|
+
throw new Error('Server is already running');
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
return new Promise((resolve, reject) => {
|
|
39
|
+
try {
|
|
40
|
+
// Create HTTP server
|
|
41
|
+
this.httpServer = createServer((req, res) => {
|
|
42
|
+
// Handle CORS preflight
|
|
43
|
+
if (req.method === 'OPTIONS') {
|
|
44
|
+
res.writeHead(200, {
|
|
45
|
+
'Access-Control-Allow-Origin': this.corsOrigin,
|
|
46
|
+
'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
|
|
47
|
+
'Access-Control-Allow-Headers': 'Content-Type, Authorization'
|
|
48
|
+
});
|
|
49
|
+
res.end();
|
|
50
|
+
return;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
// Health check endpoint
|
|
54
|
+
if (req.url === '/health') {
|
|
55
|
+
res.writeHead(200, {
|
|
56
|
+
'Content-Type': 'application/json',
|
|
57
|
+
'Access-Control-Allow-Origin': this.corsOrigin
|
|
58
|
+
});
|
|
59
|
+
res.end(JSON.stringify({
|
|
60
|
+
status: 'healthy',
|
|
61
|
+
timestamp: new Date().toISOString(),
|
|
62
|
+
uptime: process.uptime(),
|
|
63
|
+
connections: this.connections.size,
|
|
64
|
+
peers: this.peerData.size,
|
|
65
|
+
memory: process.memoryUsage()
|
|
66
|
+
}));
|
|
67
|
+
return;
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
// Default response
|
|
71
|
+
res.writeHead(200, {
|
|
72
|
+
'Content-Type': 'text/plain',
|
|
73
|
+
'Access-Control-Allow-Origin': this.corsOrigin
|
|
74
|
+
});
|
|
75
|
+
res.end('PeerPigeon WebSocket Signaling Server');
|
|
76
|
+
});
|
|
77
|
+
|
|
78
|
+
// Create WebSocket server
|
|
79
|
+
this.wss = new WebSocketServer({
|
|
80
|
+
server: this.httpServer,
|
|
81
|
+
maxPayload: this.maxMessageSize
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
this.setupWebSocketHandlers();
|
|
85
|
+
|
|
86
|
+
// Start HTTP server
|
|
87
|
+
this.httpServer.listen(this.port, this.host, () => {
|
|
88
|
+
this.isRunning = true;
|
|
89
|
+
this.startCleanupTimer();
|
|
90
|
+
|
|
91
|
+
console.log(`🚀 PeerPigeon WebSocket server started on ws://${this.host}:${this.port}`);
|
|
92
|
+
console.log(`📊 Max connections: ${this.maxConnections}`);
|
|
93
|
+
console.log(`🧹 Cleanup interval: ${this.cleanupInterval}ms`);
|
|
94
|
+
console.log(`⏰ Peer timeout: ${this.peerTimeout}ms`);
|
|
95
|
+
|
|
96
|
+
this.emit('started', { host: this.host, port: this.port });
|
|
97
|
+
resolve();
|
|
98
|
+
});
|
|
99
|
+
|
|
100
|
+
this.httpServer.on('error', (error) => {
|
|
101
|
+
console.error('❌ HTTP server error:', error);
|
|
102
|
+
this.emit('error', error);
|
|
103
|
+
reject(error);
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
} catch (error) {
|
|
107
|
+
console.error('❌ Failed to start server:', error);
|
|
108
|
+
reject(error);
|
|
109
|
+
}
|
|
110
|
+
});
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
/**
|
|
114
|
+
* Stop the WebSocket server
|
|
115
|
+
*/
|
|
116
|
+
async stop() {
|
|
117
|
+
if (!this.isRunning) {
|
|
118
|
+
return;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
return new Promise((resolve) => {
|
|
122
|
+
console.log('🛑 Stopping PeerPigeon WebSocket server...');
|
|
123
|
+
|
|
124
|
+
// Stop cleanup timer
|
|
125
|
+
if (this.cleanupTimer) {
|
|
126
|
+
clearInterval(this.cleanupTimer);
|
|
127
|
+
this.cleanupTimer = null;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
// Close all WebSocket connections
|
|
131
|
+
for (const [peerId, ws] of this.connections) {
|
|
132
|
+
try {
|
|
133
|
+
ws.close(1000, 'Server shutting down');
|
|
134
|
+
} catch (error) {
|
|
135
|
+
console.error(`Error closing connection for ${peerId}:`, error);
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
// Close WebSocket server
|
|
140
|
+
if (this.wss) {
|
|
141
|
+
this.wss.close(() => {
|
|
142
|
+
console.log('✅ WebSocket server closed');
|
|
143
|
+
|
|
144
|
+
// Close HTTP server
|
|
145
|
+
if (this.httpServer) {
|
|
146
|
+
this.httpServer.close(() => {
|
|
147
|
+
console.log('✅ HTTP server closed');
|
|
148
|
+
this.isRunning = false;
|
|
149
|
+
this.emit('stopped');
|
|
150
|
+
resolve();
|
|
151
|
+
});
|
|
152
|
+
} else {
|
|
153
|
+
this.isRunning = false;
|
|
154
|
+
this.emit('stopped');
|
|
155
|
+
resolve();
|
|
156
|
+
}
|
|
157
|
+
});
|
|
158
|
+
} else {
|
|
159
|
+
this.isRunning = false;
|
|
160
|
+
this.emit('stopped');
|
|
161
|
+
resolve();
|
|
162
|
+
}
|
|
163
|
+
});
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
/**
|
|
167
|
+
* Setup WebSocket connection handlers
|
|
168
|
+
*/
|
|
169
|
+
setupWebSocketHandlers() {
|
|
170
|
+
this.wss.on('connection', (ws, req) => {
|
|
171
|
+
const url = new URL(req.url, `http://${req.headers.host}`);
|
|
172
|
+
const peerId = url.searchParams.get('peerId');
|
|
173
|
+
|
|
174
|
+
// Validate peer ID
|
|
175
|
+
if (!peerId || !/^[a-fA-F0-9]{40}$/.test(peerId)) {
|
|
176
|
+
console.log('❌ Invalid peer ID, closing connection');
|
|
177
|
+
ws.close(1008, 'Invalid peerId format');
|
|
178
|
+
return;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
// Check connection limit
|
|
182
|
+
if (this.connections.size >= this.maxConnections) {
|
|
183
|
+
console.log('❌ Maximum connections reached, closing connection');
|
|
184
|
+
ws.close(1008, 'Maximum connections reached');
|
|
185
|
+
return;
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
// Store connection
|
|
189
|
+
this.connections.set(peerId, ws);
|
|
190
|
+
this.peerData.set(peerId, {
|
|
191
|
+
peerId,
|
|
192
|
+
connectedAt: Date.now(),
|
|
193
|
+
lastActivity: Date.now(),
|
|
194
|
+
remoteAddress: req.socket.remoteAddress
|
|
195
|
+
});
|
|
196
|
+
|
|
197
|
+
console.log(`✅ Peer connected: ${peerId.substring(0, 8)}... (${this.connections.size} total)`);
|
|
198
|
+
this.emit('peerConnected', { peerId, totalConnections: this.connections.size });
|
|
199
|
+
|
|
200
|
+
// Handle incoming messages
|
|
201
|
+
ws.on('message', (data) => {
|
|
202
|
+
try {
|
|
203
|
+
this.handleMessage(peerId, data);
|
|
204
|
+
} catch (error) {
|
|
205
|
+
console.error(`❌ Error handling message from ${peerId.substring(0, 8)}...:`, error);
|
|
206
|
+
}
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
// Handle connection close
|
|
210
|
+
ws.on('close', (code, reason) => {
|
|
211
|
+
this.handleDisconnection(peerId, code, reason);
|
|
212
|
+
});
|
|
213
|
+
|
|
214
|
+
// Handle connection error
|
|
215
|
+
ws.on('error', (error) => {
|
|
216
|
+
console.error(`❌ WebSocket error for ${peerId.substring(0, 8)}...:`, error);
|
|
217
|
+
this.handleDisconnection(peerId, 1006, 'WebSocket error');
|
|
218
|
+
});
|
|
219
|
+
|
|
220
|
+
// Send connected confirmation
|
|
221
|
+
this.sendToConnection(ws, {
|
|
222
|
+
type: 'connected',
|
|
223
|
+
data: { peerId },
|
|
224
|
+
fromPeerId: 'system',
|
|
225
|
+
timestamp: Date.now()
|
|
226
|
+
});
|
|
227
|
+
});
|
|
228
|
+
|
|
229
|
+
this.wss.on('error', (error) => {
|
|
230
|
+
console.error('❌ WebSocket server error:', error);
|
|
231
|
+
this.emit('error', error);
|
|
232
|
+
});
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
/**
|
|
236
|
+
* Handle incoming messages from peers
|
|
237
|
+
*/
|
|
238
|
+
handleMessage(peerId, data) {
|
|
239
|
+
// Update last activity
|
|
240
|
+
const peerInfo = this.peerData.get(peerId);
|
|
241
|
+
if (peerInfo) {
|
|
242
|
+
peerInfo.lastActivity = Date.now();
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
let message;
|
|
246
|
+
try {
|
|
247
|
+
message = JSON.parse(data.toString());
|
|
248
|
+
} catch (error) {
|
|
249
|
+
console.error(`❌ Invalid JSON from ${peerId.substring(0, 8)}...:`, error);
|
|
250
|
+
return;
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
// Log message type
|
|
254
|
+
console.log(`📨 Message from ${peerId.substring(0, 8)}...: ${message.type}`);
|
|
255
|
+
|
|
256
|
+
switch (message.type) {
|
|
257
|
+
case 'announce':
|
|
258
|
+
this.handleAnnounce(peerId, message);
|
|
259
|
+
break;
|
|
260
|
+
case 'goodbye':
|
|
261
|
+
this.handleGoodbye(peerId, message);
|
|
262
|
+
break;
|
|
263
|
+
case 'offer':
|
|
264
|
+
case 'answer':
|
|
265
|
+
case 'ice-candidate':
|
|
266
|
+
this.handleSignaling(peerId, message);
|
|
267
|
+
break;
|
|
268
|
+
case 'ping':
|
|
269
|
+
this.handlePing(peerId, message);
|
|
270
|
+
break;
|
|
271
|
+
case 'cleanup':
|
|
272
|
+
this.handleCleanup(peerId, message);
|
|
273
|
+
break;
|
|
274
|
+
default:
|
|
275
|
+
console.log(`❓ Unknown message type from ${peerId.substring(0, 8)}...: ${message.type}`);
|
|
276
|
+
}
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
/**
|
|
280
|
+
* Handle peer announcement
|
|
281
|
+
*/
|
|
282
|
+
handleAnnounce(peerId, message) {
|
|
283
|
+
console.log(`📢 Peer announced: ${peerId.substring(0, 8)}...`);
|
|
284
|
+
|
|
285
|
+
// Update peer data
|
|
286
|
+
const peerInfo = this.peerData.get(peerId);
|
|
287
|
+
if (peerInfo) {
|
|
288
|
+
peerInfo.announced = true;
|
|
289
|
+
peerInfo.announcedAt = Date.now();
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// Notify other peers about this peer
|
|
293
|
+
this.broadcastToOthers(peerId, {
|
|
294
|
+
type: 'peer-discovered',
|
|
295
|
+
data: {
|
|
296
|
+
peerId,
|
|
297
|
+
timestamp: Date.now(),
|
|
298
|
+
...message.data
|
|
299
|
+
},
|
|
300
|
+
fromPeerId: 'system',
|
|
301
|
+
timestamp: Date.now()
|
|
302
|
+
});
|
|
303
|
+
|
|
304
|
+
this.emit('peerAnnounced', { peerId });
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
/**
|
|
308
|
+
* Handle peer goodbye
|
|
309
|
+
*/
|
|
310
|
+
handleGoodbye(peerId, message) {
|
|
311
|
+
console.log(`👋 Peer goodbye: ${peerId.substring(0, 8)}...`);
|
|
312
|
+
|
|
313
|
+
// Notify other peers about disconnection
|
|
314
|
+
this.broadcastToOthers(peerId, {
|
|
315
|
+
type: 'peer-disconnected',
|
|
316
|
+
data: {
|
|
317
|
+
peerId,
|
|
318
|
+
reason: message.data?.reason || 'goodbye',
|
|
319
|
+
timestamp: Date.now()
|
|
320
|
+
},
|
|
321
|
+
fromPeerId: 'system',
|
|
322
|
+
timestamp: Date.now()
|
|
323
|
+
});
|
|
324
|
+
|
|
325
|
+
// Remove peer
|
|
326
|
+
this.removePeer(peerId);
|
|
327
|
+
this.emit('peerGoodbye', { peerId });
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
/**
|
|
331
|
+
* Handle WebRTC signaling messages
|
|
332
|
+
*/
|
|
333
|
+
handleSignaling(peerId, message) {
|
|
334
|
+
const targetPeerId = message.targetPeerId;
|
|
335
|
+
if (!targetPeerId) {
|
|
336
|
+
console.log(`❌ No target peer ID in signaling message from ${peerId.substring(0, 8)}...`);
|
|
337
|
+
return;
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
const targetConnection = this.connections.get(targetPeerId);
|
|
341
|
+
if (!targetConnection) {
|
|
342
|
+
console.log(`❌ Target peer ${targetPeerId.substring(0, 8)}... not found for signaling`);
|
|
343
|
+
return;
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
// Forward signaling message to target peer
|
|
347
|
+
this.sendToConnection(targetConnection, {
|
|
348
|
+
...message,
|
|
349
|
+
fromPeerId: peerId,
|
|
350
|
+
timestamp: Date.now()
|
|
351
|
+
});
|
|
352
|
+
|
|
353
|
+
console.log(`🔄 Forwarded ${message.type} from ${peerId.substring(0, 8)}... to ${targetPeerId.substring(0, 8)}...`);
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
/**
|
|
357
|
+
* Handle ping messages
|
|
358
|
+
*/
|
|
359
|
+
handlePing(peerId, message) {
|
|
360
|
+
const connection = this.connections.get(peerId);
|
|
361
|
+
if (connection) {
|
|
362
|
+
this.sendToConnection(connection, {
|
|
363
|
+
type: 'pong',
|
|
364
|
+
data: { timestamp: Date.now() },
|
|
365
|
+
fromPeerId: 'system',
|
|
366
|
+
targetPeerId: peerId,
|
|
367
|
+
timestamp: Date.now()
|
|
368
|
+
});
|
|
369
|
+
}
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
/**
|
|
373
|
+
* Handle cleanup messages
|
|
374
|
+
*/
|
|
375
|
+
handleCleanup(peerId, message) {
|
|
376
|
+
console.log(`🧹 Cleanup request from ${peerId.substring(0, 8)}...`);
|
|
377
|
+
// Cleanup is handled by the cleanup timer
|
|
378
|
+
// This is just for logging purposes
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
/**
|
|
382
|
+
* Handle peer disconnection
|
|
383
|
+
*/
|
|
384
|
+
handleDisconnection(peerId, code, reason) {
|
|
385
|
+
console.log(`❌ Peer disconnected: ${peerId.substring(0, 8)}... (code: ${code}, reason: ${reason})`);
|
|
386
|
+
|
|
387
|
+
// Notify other peers about disconnection
|
|
388
|
+
this.broadcastToOthers(peerId, {
|
|
389
|
+
type: 'peer-disconnected',
|
|
390
|
+
data: {
|
|
391
|
+
peerId,
|
|
392
|
+
reason: reason?.toString() || 'disconnected',
|
|
393
|
+
timestamp: Date.now()
|
|
394
|
+
},
|
|
395
|
+
fromPeerId: 'system',
|
|
396
|
+
timestamp: Date.now()
|
|
397
|
+
});
|
|
398
|
+
|
|
399
|
+
// Remove peer
|
|
400
|
+
this.removePeer(peerId);
|
|
401
|
+
this.emit('peerDisconnected', { peerId, code, reason, totalConnections: this.connections.size });
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
/**
|
|
405
|
+
* Remove peer from server
|
|
406
|
+
*/
|
|
407
|
+
removePeer(peerId) {
|
|
408
|
+
this.connections.delete(peerId);
|
|
409
|
+
this.peerData.delete(peerId);
|
|
410
|
+
console.log(`🗑️ Removed peer: ${peerId.substring(0, 8)}... (${this.connections.size} remaining)`);
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
/**
|
|
414
|
+
* Send message to specific connection
|
|
415
|
+
*/
|
|
416
|
+
sendToConnection(connection, message) {
|
|
417
|
+
if (connection.readyState === connection.OPEN) {
|
|
418
|
+
try {
|
|
419
|
+
connection.send(JSON.stringify(message));
|
|
420
|
+
return true;
|
|
421
|
+
} catch (error) {
|
|
422
|
+
console.error('❌ Failed to send message:', error);
|
|
423
|
+
return false;
|
|
424
|
+
}
|
|
425
|
+
}
|
|
426
|
+
return false;
|
|
427
|
+
}
|
|
428
|
+
|
|
429
|
+
/**
|
|
430
|
+
* Broadcast message to all peers except the sender
|
|
431
|
+
*/
|
|
432
|
+
broadcastToOthers(senderPeerId, message) {
|
|
433
|
+
let sentCount = 0;
|
|
434
|
+
for (const [peerId, connection] of this.connections) {
|
|
435
|
+
if (peerId !== senderPeerId) {
|
|
436
|
+
if (this.sendToConnection(connection, {
|
|
437
|
+
...message,
|
|
438
|
+
targetPeerId: peerId
|
|
439
|
+
})) {
|
|
440
|
+
sentCount++;
|
|
441
|
+
}
|
|
442
|
+
}
|
|
443
|
+
}
|
|
444
|
+
console.log(`📡 Broadcast to ${sentCount} peers`);
|
|
445
|
+
return sentCount;
|
|
446
|
+
}
|
|
447
|
+
|
|
448
|
+
/**
|
|
449
|
+
* Start cleanup timer
|
|
450
|
+
*/
|
|
451
|
+
startCleanupTimer() {
|
|
452
|
+
this.cleanupTimer = setInterval(() => {
|
|
453
|
+
this.performCleanup();
|
|
454
|
+
}, this.cleanupInterval);
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
/**
|
|
458
|
+
* Perform cleanup of inactive connections
|
|
459
|
+
*/
|
|
460
|
+
performCleanup() {
|
|
461
|
+
const now = Date.now();
|
|
462
|
+
const disconnectedPeers = [];
|
|
463
|
+
|
|
464
|
+
for (const [peerId, peerInfo] of this.peerData) {
|
|
465
|
+
if (now - peerInfo.lastActivity > this.peerTimeout) {
|
|
466
|
+
console.log(`🧹 Cleaning up inactive peer: ${peerId.substring(0, 8)}...`);
|
|
467
|
+
|
|
468
|
+
const connection = this.connections.get(peerId);
|
|
469
|
+
if (connection) {
|
|
470
|
+
try {
|
|
471
|
+
connection.close(1000, 'Inactive timeout');
|
|
472
|
+
} catch (error) {
|
|
473
|
+
console.error(`Error closing inactive connection for ${peerId}:`, error);
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
|
|
477
|
+
disconnectedPeers.push(peerId);
|
|
478
|
+
}
|
|
479
|
+
}
|
|
480
|
+
|
|
481
|
+
// Remove disconnected peers
|
|
482
|
+
disconnectedPeers.forEach(peerId => {
|
|
483
|
+
this.removePeer(peerId);
|
|
484
|
+
});
|
|
485
|
+
|
|
486
|
+
if (disconnectedPeers.length > 0) {
|
|
487
|
+
console.log(`🧹 Cleaned up ${disconnectedPeers.length} inactive peers`);
|
|
488
|
+
}
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
/**
|
|
492
|
+
* Get server statistics
|
|
493
|
+
*/
|
|
494
|
+
getStats() {
|
|
495
|
+
return {
|
|
496
|
+
isRunning: this.isRunning,
|
|
497
|
+
connections: this.connections.size,
|
|
498
|
+
peers: this.peerData.size,
|
|
499
|
+
maxConnections: this.maxConnections,
|
|
500
|
+
uptime: this.isRunning ? Date.now() - this.startTime : 0,
|
|
501
|
+
host: this.host,
|
|
502
|
+
port: this.port
|
|
503
|
+
};
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
/**
|
|
507
|
+
* Get list of connected peers
|
|
508
|
+
*/
|
|
509
|
+
getPeers() {
|
|
510
|
+
return Array.from(this.peerData.values());
|
|
511
|
+
}
|
|
512
|
+
}
|
|
513
|
+
|
|
514
|
+
// For backwards compatibility and standalone usage
|
|
515
|
+
export default PeerPigeonServer;
|