@hive-p2p/server 1.0.49 → 1.0.50

package/core/ice-offer-manager.mjs

@@ -139,6 +139,24 @@ export class OfferManager { // Manages the creation of SDP offers and handling o
 
 		if (this.verbose > 0) console.error(`transportInstance ERROR => `, error.stack);
 	};
+
+	bestReadyOffer(maxSent = 0, avoidCloseExpiration = true) { // the most recent offer that is not used
+		/** @type {OfferObj | null} */ let readyOffer = null;
+		/** @type {string | null} */ let offerHash = null;
+		/** @type {number | null} */ let since = null;
+		for (const hash in this.offers) {
+			const offer = this.offers[hash];
+			const { isUsed, sentCounter, signal, timestamp } = offer;
+			if (isUsed || sentCounter > maxSent) continue; // already used or already sent at least once
+			const createdSince = CLOCK.time - timestamp;
+			if (avoidCloseExpiration && createdSince > TRANSPORTS.SDP_OFFER_EXPIRATION / 2) continue; // old, don't spread
+			if (since && createdSince > since) continue; // already have a better (more recent) offer
+			readyOffer = offer; offerHash = hash; since = createdSince;
+			break;
+		}
+
+		return { offerHash, readyOffer, since };
+	}
 	/** @param {string} remoteId @param {{type: 'answer', sdp: Record<string, string>}} signal @param {string} offerHash @param {number} timestamp receptionTimestamp */
 	addSignalAnswer(remoteId, signal, offerHash, timestamp) {
 		if (!signal || signal.type !== 'answer' || !offerHash) return; // ignore non-answers or missing offerHash

package/core/node.mjs

@@ -140,23 +140,11 @@ export class Node {
 		else this.messager.handleDirectMessage(peerId, d);
 	}
 
-	// PUBLIC API
+	// PUBLIC API -------------------------------------------------------------
 	/** @returns {string | undefined} */
 	get publicUrl() { return this.services?.publicUrl; }
 	get time() { return CLOCK.time; }
 
-	/** Triggered when a new peer connection is established.
-	 *  @param {function} callback can use arguments: (peerId:string, direction:string) */
-	onPeerConnect(callback) { this.peerStore.on('connect', callback); }
-	
-	/** Triggered when a new message is received.
-	 *  @param {function} callback can use arguments: (senderId:string, data:any) */
-	onMessageData(callback) { this.messager.on('message', callback); }
-
-	/** Triggered when a new gossip message is received.
-	 * @param {function} callback can use arguments: (senderId:string, topic:string, data:any) */
-	onGossipData(callback) { this.gossip.on('gossip', callback); }
-	
 	async start() {
 		await CLOCK.sync(this.verbose);
 		this.started = true;
@@ -170,19 +158,23 @@ export class Node {
 		this.topologist.tryConnectNextBootstrap(); // first shot ASAP
 		return true;
 	}
+	
 	/** Broadcast a message to all connected peers or to a specified peer
 	 * @param {string | Uint8Array | Object} data @param {string} topic  @param {string} [targetId] default: broadcast to all
 	 * @param {number} [timestamp] default: CLOCK.time @param {number} [HOPS] default: GOSSIP.HOPS[topic] || GOSSIP.HOPS.default */
 	broadcast(data, topic, HOPS) { this.gossip.broadcastToAll(data, topic, HOPS); }
+	
 	/** @param {string} remoteId @param {string | Uint8Array | Object} data @param {string} type */
 	sendMessage(remoteId, data, type, spread = 1) { this.messager.sendUnicast(remoteId, data, type, spread); }
-	async tryConnectToPeer(targetId = 'toto', retry = 5) { // TO REFACTO
-		console.info('FUNCTION DISABLED FOR NOW');
-		/*if (this.peerStore.connected[targetId]) return; // already connected
+
+	/** Send a connection request to a peer */
+	async tryConnectToPeer(targetId = 'toto', retry = 5) {
+		if (this.peerStore.connected[targetId]) return; // already connected
 		do {
-			if (this.peerStore.offerManager.readyOffer) break;
-			else await new Promise(r => setTimeout(r, 1000)); // build in progress...
-		} while (retry-- > 0);*/
+			const { offerHash, readyOffer } = this.peerStore.offerManager.bestReadyOffer(100, false);
+			if (!offerHash || !readyOffer) await new Promise(r => setTimeout(r, 1000)); // build in progress...
+			else this.messager.sendUnicast(targetId, { signal: readyOffer.signal, offerHash }, 'signal_offer', 1);
+		} while (retry-- > 0);
 	}
 	destroy() {
 		if (this.enhancerInterval) clearInterval(this.enhancerInterval);
@@ -193,4 +185,30 @@ export class Node {
 		if (this.wsServer) this.wsServer.close();
 		if (this.stunServer) this.stunServer.close();
 	}
+
+	// HANDLERS REGISTRATION --------------------------------------------------
+
+	/** Triggered when a new peer connection is established.
+	 *  @param {function} callback can use arguments: (peerId:string, direction:string) */
+	onPeerConnect(callback) { this.peerStore.on('connect', callback); }
+	
+	/** Triggered when a peer connection is closed.
+	 *  @param {function} callback can use arguments: (peerId:string, direction:string) */
+	onPeerDisconnect(callback) { this.peerStore.on('disconnect', callback); }
+
+	/** Triggered when a new message is received.
+	 *  @param {function} callback can use arguments: (senderId:string, data:any) */
+	onMessageData(callback) { this.messager.on('message', callback); }
+
+	/** Triggered when a new gossip message is received.
+	 * @param {function} callback can use arguments: (senderId:string, topic:string, data:any) */
+	onGossipData(callback) { this.gossip.on('gossip', callback); }
+
+	/** Triggered when a new signal offer is received from another peer.
+	 *  @param {function} callback can use arguments: (senderId:string, data:SignalData) */
+	onSignalOffer(callback) { this.messager.on('signal_offer', callback); this.gossip.on('signal_offer', callback); }
+
+	/** Triggered when a new signal answer is received from another peer.
+	 * @param {function} callback can use arguments: (senderId:string, data:SignalData) */
+	onSignalAnswer(callback) { this.messager.on('signal_answer', callback); }
 }

package/core/topologist.mjs

@@ -59,6 +59,7 @@ export class Topologist {
 		this.TWICE_TARGET = this.NEIGHBORS_TARGET * 2;
 	}
 
+	automation = { incomingOffer: true, incomingAnswer: true, spreadOffers: true, connectBootstraps: true };
 	phase = 0; nextBootstrapIndex = 0;
 	maxBonus = NODE.CONNECTION_UPGRADE_TIMEOUT * .2; // 20% of 15sec: 3sec max
 	get isPublicNode() { return this.services?.publicUrl ? true : false; }
@@ -97,6 +98,7 @@ export class Topologist {
 		if (isTooMany || connected[senderId]) return;
 
 		if (signal.type === 'answer') { // ANSWER SHORT CIRCUIT => Rich should connect poor, and poor should connect rich.
+			if (!this.automation.incomingAnswer) return;
 			if (this.peerStore.addConnectingPeer(senderId, signal, offerHash) !== true) return;
 			const delta = Math.abs(nonPublicNeighborsCount - this.#getOverlap(senderId).nonPublicCount);
 			const bonusPerDeltaPoint = this.maxBonus / this.NEIGHBORS_TARGET; // from 0 to maxBonus
@@ -105,6 +107,7 @@ export class Topologist {
 		}
 
 		// OFFER
+		if (!this.automation.incomingOffer) return;
 		if (nonPublicNeighborsCount > this.TWICE_TARGET) return; // we are over connected, ignore the offer
 		const { overlap, nonPublicCount } = this.#getOverlap(senderId);
 		if (nonPublicCount > this.TWICE_TARGET) return; // the sender is over connected, ignore the offer
@@ -114,6 +117,7 @@ export class Topologist {
 		this.offersQueue.pushSortTrim(offerItem);
 	}
 	tryConnectNextBootstrap(neighborsCount = 0, nonPublicNeighborsCount = 0) {
+		if (!this.automation.connectBootstraps) return;
 		if (this.bootstraps.length === 0) return;
 		const publicConnectedCount = neighborsCount - nonPublicNeighborsCount;
 		let connectingCount = 0;
@@ -197,23 +201,14 @@ export class Topologist {
 		};		
 	}
 	#tryToSpreadSDP(nonPublicNeighborsCount = 0, isHalfReached = false) { // LOOP TO SELECT ONE UNSEND READY OFFER AND BROADCAST IT
+		if (!this.automation.spreadOffers) return;
 		if (!this.peerStore.neighborsList.length) return; // no neighbors, no need to spread offers
 		// LIMIT OFFER SPREADING IF WE ARE CONNECTING TO MANY PEERS, LOWER GOSSIP TRAFFIC
 		const connectingCount = Object.keys(this.peerStore.connecting).length;
 		const ingPlusEd = connectingCount + nonPublicNeighborsCount;
 		
 		// SELECT BEST READY OFFER BASED ON TIMESTAMP
-		let [ offerHash, readyOffer, since ] = [ null, null, null ];
-		for (const hash in this.peerStore.offerManager.offers) {
-			const offer = this.peerStore.offerManager.offers[hash];
-			const { isUsed, sentCounter, signal, timestamp } = offer;
-			if (isUsed || sentCounter > 0) continue; // already used or already sent at least once
-			const createdSince = CLOCK.time - timestamp;
-			if (createdSince > TRANSPORTS.SDP_OFFER_EXPIRATION / 2) continue; // old, don't spread
-			if (since && createdSince > since) continue; // already have a better (more recent) offer
-			readyOffer = offer; offerHash = hash; since = createdSince;
-			break;
-		}
+		const { offerHash, readyOffer } = this.peerStore.offerManager.bestReadyOffer(0, true);
 		if (!offerHash || !readyOffer) return; // no ready offer to spread
 
 		// IF WE ARE CONNECTED TO LESS 2 (WRTC) AND NOT TO MUCH CONNECTING, WE CAN BROADCAST IT TO ALL

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hive-p2p/server",
-  "version": "1.0.49",
+  "version": "1.0.50",
   "publishConfig": {
     "access": "public"
   },