webpeerjs 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpeerjs",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "WebPEER.js is decentralized P2P JS library for communication between applications in browser.",
   "main": "./dist/umd/webpeerjs.js",
   "module": "./src/webpeerjs.js",
@@ -32,17 +32,17 @@
     "url": "git+https://github.com/nuzulul/webpeerjs.git"
   },
   "keywords": [
-    "p2p",
+    "webpeer",
+	"p2p",
+	"p2p-network",
+	"webpeer-network",
     "ipfs",
 	"libp2p",
     "peer",
     "peer-to-peer",
     "decentralized",
     "browser-to-browser",
-	"dapp",
 	"distributed",
-	"decentralized-web",
-	"distributed-web",
 	"serverless"
   ],
   "author": {

package/src/utils.js

@@ -121,6 +121,7 @@ let lastStats = {
 }
 
 let fail = 0
+let lastfail = 0
 let isDialEnabled = true
 let lastfailtreshold = 0
 let isAutoDialEnabled = true
@@ -185,6 +186,20 @@ export function metrics(data){
 		
 		fail = errors+timeouts
 		//const treshold = errors+timeouts+stats.open+stats.pending
+		//console.log('fail',fail)
+		
+		//detect fail timeout, in chrome fail webtransport get reset after 5 minutes
+		if(lastfail>fail){
+			setTimeout(()=>{
+				if(isAutoDialEnabled){
+					lastfailtresholdauto = lastfailtresholdauto+(lastfail-fail)
+				}
+				if(isDialEnabled){
+					lastfailtreshold = lastfailtreshold+(lastfail-fail)
+				}
+			},5*60*1000)
+		}
+		lastfail = fail
 		
 		if ((fail-lastfailtreshold)>config.CONFIG_DIAL_MAX_ERROR_LIMIT){
 			if(isDialEnabled){

package/src/webpeerjs.js

@@ -92,6 +92,9 @@ class webpeerjs{
 	//message tracker avoid double
 	#msgIdtracker
 	
+	//inbound message time tracker
+	#msgTimeTracker
+	
 	//map of peer exchange data
 	#peerexchangedata
 	
@@ -105,6 +108,9 @@ class webpeerjs{
 	//callback to websocket dialable
 	#onWebsocketFn
 	
+	//time tracker for sending message
+	#sendMessageTimeTracker
+	
 	id
 	status
 	IPFS
@@ -133,11 +139,13 @@ class webpeerjs{
 		this.#trackDisconnect = new Map()
 		this.#dialQueue = []
 		this.#isDialEnabled = true
-		this.#msgIdtracker = []
+		this.#msgIdtracker = new Map()
 		this.#peerexchangedata = new Map()
 		this.#lastTimeConnectToNetwork = new Date().getTime()
 		this.#lastTimeReceiveData = new Date().getTime()
 		this.#onConnectQueue = []
+		this.#msgTimeTracker = new Map()
+		this.#sendMessageTimeTracker = 0
 		
 		this.peers = (function(f) {
 			return f
@@ -386,10 +394,17 @@ class webpeerjs{
 									}
 
 									//inbound message
+									//use #msgIdtracker to prevent double message
+									//use #msgTimeTracker to limit inbound message 1msg/s
 									if(message){
 										const msgID = msgId+id
-										if(!this.#msgIdtracker.includes(msgID)){
-											this.#msgIdtracker.push(msgID)
+										let oldmsgtime = 0
+										let newmsgtime = new Date().getTime()
+										if(this.#msgTimeTracker.has(id))oldmsgtime = this.#msgTimeTracker.get(id)
+										const msgtimelimit = 1000
+										if(!this.#msgIdtracker.has(msgID) && newmsgtime-oldmsgtime>msgtimelimit){
+											this.#msgIdtracker.set(msgID,newmsgtime)
+											this.#msgTimeTracker.set(id,newmsgtime)
 											this.#rooms[room].onMessage(message,id)
 										}
 									}
@@ -695,6 +710,7 @@ class webpeerjs{
 			this.#peerDiscoveryHybrid()
 			this.#trackHybridPeersConnection()
 			this.#trackWebpeerConnection()
+			this.#garbageCollectionMsgIdTracker()
 		},10e3)
 		
 
@@ -774,6 +790,11 @@ class webpeerjs{
 				onMessage : () => {},
 				listenMessage : f => (this.#rooms[room] = {...this.#rooms[room], onMessage: f}),
 				sendMessage : async (message) => {
+					const now = (new Date()).getTime()
+					if(now-this.#sendMessageTimeTracker < 1000){
+						throw mkErr('can not send more than 1 message/s')
+					}
+					this.#sendMessageTimeTracker = now
 					const msgId = (new Date()).getTime()
 					const data = JSON.stringify({prefix:config.CONFIG_PREFIX,room,message,id:this.#libp2p.peerId.toString(),msgId})
 					const arr = uint8ArrayFromString(data)
@@ -809,12 +830,25 @@ class webpeerjs{
 		mddrs.push(mddr)
 		this.#dialMultiaddress(mddrs)
 	}
+	
+	plugin(callback){
+		callback(this)
+	}
 
 
 	/*
 	PRIVATE FUNCTION
 	*/
 	
+	#garbageCollectionMsgIdTracker(){
+		const limit = 60*1000
+		for(const msg of this.#msgIdtracker){
+			if(msg[1] > limit){
+				this.#msgIdtracker.delete(msg[0])
+			}
+		}
+	}
+	
 	//track hybrid peer connection and try to dial if not connected at least 1
 	#trackHybridPeersConnection(){
 		let isConnectedToHybridPeers = false
@@ -1863,6 +1897,9 @@ class webpeerjs{
 			listenaddress.push('/webrtc')
 		}
 		
+		const stunurls = config.CONFIG_WEBRTC_STUN_URLS
+		const stunurlsbackup = config.CONFIG_WEBRTC_STUN_URLS_BACKUP
+		
 		const turnurls = atob(config.CONFIG_WEBRTC_TURN_HOST)
 		const turnusername = atob(config.CONFIG_WEBRTC_TURN_USER)
 		const turncredential = atob(config.CONFIG_WEBRTC_TURN_PWD)
@@ -1871,95 +1908,114 @@ class webpeerjs{
 		const turnusernamebackup = atob(config.CONFIG_WEBRTC_TURN_USER_BACKUP)
 		const turncredentialbackup = atob(config.CONFIG_WEBRTC_TURN_PWD_BACKUP)
 		
-		const ice = await new Promise((resolve)=>{
-			
-			let stun = false
-			let turn = false
-			
-			const timeout = setTimeout(()=>{
-				let ice = []
-				if(stun){
-					ice.push(stun)
-				}else{
-					const backup = {
-						urls: config.CONFIG_WEBRTC_STUN_URLS_BACKUP
-					}
-					ice.push(backup)
-				}
-				if(turn){
-					ice.push(turn)
-				}else{
-					const backup = 	{
-						urls: turnurlsbackup, 
-						username: turnusernamebackup, 
-						credential: turncredentialbackup
-					}
-					ice.push(backup)
-				}
-				resolve(ice)
-			},5000)
-			
-			function check(){
-				if(stun && turn){
+		async function checkice(stunurls,turnurls,turnusername,turncredential,time){
+			return new Promise((resolve)=>{
+				
+				let stun = false
+				let turn = false
+				
+				const timeout = setTimeout(()=>{
 					let ice = []
 					ice.push(stun)
 					ice.push(turn)
-					clearTimeout(timeout)
 					resolve(ice)
+				},time)
+				
+				function check(){
+					if(stun && turn){
+						let ice = []
+						ice.push(stun)
+						ice.push(turn)
+						clearTimeout(timeout)
+						resolve(ice)
+					}
 				}
-			}
-			
-			//test ice servers
-			
-			const iceServers = [
-				{
-					urls: config.CONFIG_WEBRTC_STUN_URLS
-				},
-				{
-					urls: turnurls, 
-					username: turnusername, 
-					credential: turncredential
-				}
-			];
+				
+				//test ice servers
+				
+				const iceServers = [
+					{
+						urls: stunurls
+					},
+					{
+						urls: turnurls, 
+						username: turnusername, 
+						credential: turncredential
+					}
+				];
 
-			const pc = new RTCPeerConnection({
-				iceServers
-			});
+				const pc = new RTCPeerConnection({
+					iceServers
+				});
 
-			pc.onicecandidate = (e) => {
-				if (!e.candidate) return;
+				pc.onicecandidate = (e) => {
+					if (!e.candidate) return;
 
-				//console.log(e.candidate.candidate);
+					//console.log(e.candidate.candidate);
 
-				// stun works
-				if(e.candidate.type == "srflx"){
-					//console.log('publicip',e.candidate.address);
-					stun = 	{
-								urls: config.CONFIG_WEBRTC_STUN_URLS
-							}
-					check()
-				}
+					// stun works
+					if(e.candidate.type == "srflx"){
+						//console.log('publicip',e.candidate.address);
+						stun = 	{
+									urls: stunurls
+								}
+						check()
+					}
 
-				// turn works
-				if(e.candidate.type == "relay"){
-					turn =  {
-								urls: turnurls, 
-								username: turnusername, 
-								credential: turncredential
-							}
-					check()
-				}
-			};
+					// turn works
+					if(e.candidate.type == "relay"){
+						turn =  {
+									urls: turnurls, 
+									username: turnusername, 
+									credential: turncredential
+								}
+						check()
+					}
+				};
 
-			pc.onicecandidateerror = (e) => {
-				console.debug(e);
-			};
+				pc.onicecandidateerror = (e) => {
+					console.debug(e);
+				};
 
-			pc.createDataChannel('webpeerjs');
-			pc.createOffer().then(offer => pc.setLocalDescription(offer));
-		})
+				pc.createDataChannel('webpeerjs');
+				pc.createOffer().then(offer => pc.setLocalDescription(offer));
+			})
+		}
+		
+		let ice = await checkice(stunurls,turnurls,turnusername,turncredential,5000)
+		
+		//console.log(ice)
+		
+		//recheck ice
+		if(!ice[0] && !ice[1]){
+			ice = await checkice(stunurlsbackup,turnurlsbackup,turnusernamebackup,turncredentialbackup,5000)
+		}else if (ice[0] && !ice[1]){
+			ice = await checkice(stunurls,turnurlsbackup,turnusernamebackup,turncredentialbackup,5000)
+		}else if (!ice[0] && ice[1]){
+			ice = await checkice(stunurlsbackup,turnurls,turnusername,turncredential,5000)
+		}
+		
 		//console.log(ice)
 		
+		//final ice remove false value
+		ice.forEach(function(value, index) {
+		  if(!value){
+			  this.splice(index, 1)
+		  }
+		}, ice);
+		
+		//console.log(ice)
+		
+		let configuration = {}
+		
+		if(arguments.length > 0){
+			configuration = arguments[0]
+		}else{
+			configuration.rtcConfiguration = {
+				iceServers: ice,
+			}
+		}
+		
 		//create libp2p instance
 		const libp2p = await createLibp2p({
 			addresses: {
@@ -1969,9 +2025,7 @@ class webpeerjs{
 				webTransport(),
 				webSockets(),
 				webRTC({
-					rtcConfiguration: {
-						iceServers: ice,
-					},
+					rtcConfiguration: configuration.rtcConfiguration,
 				}),
 				circuitRelayTransport({
 					discoverRelays: config.CONFIG_DISCOVER_RELAYS,