Fixed bugs in peermgr, network, inventory relaying on connect.

Author: ebfull

btc/inventory.js

@@ -74,7 +74,7 @@ function Inventory(self) {
 		for (var p in this.tellPeer) {
 			var invPacket = this.tellPeer[p];
 
-			if (Object.keys(invPacket) != 0) {
+			if (Object.keys(invPacket).length != 0) {
 				doneSomething = true;
 				this.__send_inv(p, invPacket)
 
@@ -225,17 +225,24 @@ function Inventory(self) {
 	}
 
 	self.on("peermgr:connect", function(from) {
+		var relaySet = this.objects.find({status:"relay"});
+
 		this.peerHas[from] = {};
 		this.tellPeer[from] = {};
 		this.mapAskFor[from] = {};
 
-		// todo: send full inventory
+		relaySet.forEach(function(o) {
+			this.tellPeer[from][o.id] = o.type;
+		}, this)
+
+		this.addTick();
 	}, this)
 
 	self.on("peermgr:disconnect", function(from) {
 		delete this.peerHas[from]
 		delete this.tellPeer[from]
 		delete this.mapAlreadyAskedFor[from]
+		delete this.mapAskFor[from];
 	}, this)
 
 	self.on("inv", this.onInv, this)

network.js

@@ -100,7 +100,7 @@ function NodeTickEvent(delay, f, ctx) {
 
 	this.run = function(network) {
 		var newDelay;
-		if (newDelay = f.call(ctx) !== false) {
+		if ((newDelay = f.call(ctx)) !== false) {
 			if (typeof newDelay == "number")
 				this.delay = newDelay;
 

peermgr.js

@@ -23,6 +23,7 @@ function PeerMgr(self) {
 	// self.peers = this;
 	self.peermgr = this;
 
+	this.ticking = false;
 	this.peers = {}; // current established or attempted connections
 	this.numpeers = 0; // the number of peers we have
 	this.maxpeers = 8; // the max number of peers we can have
@@ -33,8 +34,6 @@ function PeerMgr(self) {
 
 	var peerTick = function() {
 		if (this.numpeers < this.maxpeers) {
-			if (self.now() > 1000 * 1000) // after 1000 seconds, let's not bother trying to form new connections and assume the network is in a steady state
-				return false;
 			// we need more peers
 
 			// let's try connecting to a peer in our nodearchive, if there are any
@@ -54,11 +53,36 @@ function PeerMgr(self) {
 					this.getpeers(randomPeer.id)
 				}
 			}
+
+			if (self.now() > 1000 * 1000) // after 1000 seconds, let's tick every 5 seconds instead
+				return 5000;
 		} else {
+			_ticking = false;
+			self.peermgr.ticking = false;
 			return false; // no more ticking necessary
 		}
 	}
 
+	var _ticking = false;
+	var startTicking = function() {
+		if (!_ticking) {
+			_ticking = true;
+			self.peermgr.ticking = true;
+
+			self.tick(1000, peerTick, self.peermgr);
+		}
+	}
+
+	this.numActive = function() {
+		var n = 0;
+		for (var p in this.peers) {
+			if (this.peers[p].active) {
+				n++;
+			}
+		}
+		return n;
+	}
+
 	this.send = function(to, name, msg) {
 		if (this.peers[to].active) {
 			if (this.peers[to].locked) {
@@ -115,8 +139,16 @@ function PeerMgr(self) {
 	// disconnect from a remote node
 	this.disconnect = function(p) {
 		if (typeof this.peers[p] != "undefined") {
-			this.nodearchive.push(this.peers[p]);
-			delete this.peers[p]
+			var peer = this.peers[p];
+			delete this.peers[p];
+
+			//if (peer.active) {
+				self.send(p, 'disconnect', {})
+				self.disconnect(p);
+				startTicking();
+			//}
+
+			this.nodearchive.push(peer);
 			this.numpeers -= 1;
 			self.handle(p, "peermgr:disconnect", p)
 		}
@@ -179,7 +211,7 @@ function PeerMgr(self) {
 					}
 				}
 
-				this.nodearchive.unshift(new PeerState(candidate.id, self.now()))
+				this.nodearchive.push(new PeerState(candidate.id, self.now()))
 			}
 		}
 	}
@@ -257,7 +289,7 @@ function PeerMgr(self) {
 		var rejectPeer = new PeerState(from, self.now());
 
 		// add back to nodearchive in the front
-		this.nodearchive.unshift(rejectPeer)
+		this.nodearchive.push(rejectPeer)
 
 		// send node a rejection message
 		this.reject(rejectPeer);
@@ -268,7 +300,7 @@ function PeerMgr(self) {
 	//
 
 	// tick that runs every 1 second
-	self.tick(1000, peerTick, this);
+	startTicking();
 
 	self.on("connect", this.onConnect, this);
 	self.on("accept", this.onAccept, this);

sim.js

@@ -13,6 +13,8 @@ btc.Blockchain.GenesisBlock.difficulty = 3700;
 client.use(peermgr)
 client.use(btc)
 
+var hashrate = 1;
+
 client.init(function() {
 	var self = this;
 
@@ -184,7 +186,54 @@ client.init(function() {
 		}
 	}, this.miner)
 ////////////////////////////////////////////////
-	this.mine(0.01);
+	var myHashrate = (hashrate / 2) * Math.random();
+	hashrate -= myHashrate;
+	this.mine(myHashrate);
+////////////////////////////////////////////////
+	// adjust peering relationships based on who sends us blocks!
+
+	var funpeers = {};
+	this.on("peermgr:connect", function(id) {
+		funpeers[id] = {blocks:0};
+		return true;
+	})
+	this.on("peermgr:disconnect", function(id) {
+		delete funpeers[id];
+		return true;
+	})
+	this.on("obj:block", function(from, b) {
+		funpeers[from].blocks++;
+		return true;
+	})
+	this.tick(100 * 1000, function() {
+		if (this.peermgr.numActive() != this.peermgr.maxpeers) {
+			return true;
+		}
+		// every 100 seconds boot off a poorly performing peer
+		var worst_n = Infinity;
+		var worst = null;
+
+		var t = 0;
+
+		for (var p in funpeers) {
+			t += funpeers[p].blocks;
+			if (funpeers[p].blocks < worst_n) {
+				worst_n = funpeers[p].blocks;
+				worst = p;
+			}
+		}
+
+		if (t < 20) // we want a sample of 20 blocks
+			return true;
+
+		if (worst != null) {
+			this.peermgr.disconnect(worst);
+		}
+
+		for (var p in funpeers) {
+			funpeers[p].blocks = 0;
+		}
+	})
 })
 
 net.add(100, client)