Grow peers uses latest mechanisms.

libdevcore/RangeMask.h

@@ -181,7 +181,7 @@ public:
 	}
 
 	std::pair<T, T> const& all() const { return m_all; }
-	void extendAll(T _max) { m_all.second = _max + 1; }
+	void extendAll(T _i) { m_all = std::make_pair(std::min(m_all.first, _i), std::max(m_all.second, _i + 1)); }
 
 	class const_iterator
 	{

libp2p/Host.cpp

@@ -396,6 +396,7 @@ Nodes Host::potentialPeers(RangeMask<unsigned> const& _known)
 {
 	RecursiveGuard l(x_peers);
 	Nodes ret;
+
 	for (auto i: m_ready - (m_private + _known))
 		ret.push_back(*m_nodes[m_nodesList[i]]);
 	return ret;
@@ -530,16 +531,48 @@ bool Host::havePeer(NodeId _id) const
 	return !!m_peers.count(_id);
 }
 
+unsigned cumulativeFallback(unsigned _failed)
+{
+	if (_failed < 5)
+		return _failed * 5;
+	else if (_failed < 15)
+		return 25 + (_failed - 5) * 10;
+	else
+		return 25 + 100 + (_failed - 15) * 20;
+}
+
 void Host::growPeers()
 {
 	RecursiveGuard l(x_peers);
-	while (m_peers.size() < m_idealPeerCount)
+	int morePeers = (int)m_idealPeerCount - m_peers.size();
-	{
+	if (morePeers > 0)
-		// TODO: Make work with m_ready/m_private using all the Node information.
+	{
-		if (m_freePeers.empty())
+		auto toTry = m_ready;
+		if (m_netPrefs.localNetworking)
+			toTry -= m_private;
+		set<Node> ns;
+		for (auto i: toTry)
+			if (chrono::system_clock::now() > m_nodes[m_nodesList[i]]->lastAttempted + chrono::seconds(cumulativeFallback(m_nodes[m_nodesList[i]]->failedAttempts)))
+				ns.insert(*m_nodes[m_nodesList[i]]);
+
+		if (ns.size())
+			for (Node const& i: ns)
+			{
+				m_nodes[i.id]->connect(this);
+				if (!--morePeers)
+					return;
+			}
+		else
 		{
+			ensureAccepting();
 			if (chrono::steady_clock::now() > m_lastPeersRequest + chrono::seconds(10))
-			{
+				requestPeers();
+		}
+	}
+}
+
+void Host::requestPeers()
+{
 	RLPStream s;
 	bytes b;
 	Session::prep(s, GetPeersPacket).swapOut(b);
@@ -549,19 +582,6 @@ void Host::growPeers()
 			if (p->isOpen())
 				p->send(&b);
 	m_lastPeersRequest = chrono::steady_clock::now();
-			}
-
-			if (!m_accepting)
-				ensureAccepting();
-
-			break;
-		}
-
-		auto x = time(0) % m_freePeers.size();
-		if (!m_peers.count(m_freePeers[x]))
-			connect(m_nodes[m_freePeers[x]]->address);
-		m_freePeers.erase(m_freePeers.begin() + x);
-	}
 }
 
 void Host::prunePeers()

libp2p/Host.h

@@ -71,6 +71,26 @@ struct Node
 
 	Origin idOrigin = Origin::Unknown;				///< Thirdparty
 
+	bool offline() const { return lastDisconnect == -1 || lastAttempted > lastConnected; }
+	bool operator<(Node const& _n) const
+	{
+		if (offline() != _n.offline())
+			return offline();
+		else if (offline())
+			if (lastAttempted == _n.lastAttempted)
+				return failedAttempts < _n.failedAttempts;
+			else
+				return lastAttempted < _n.lastAttempted;
+		else
+			if (score == _n.score)
+				if (rating == _n.rating)
+					return failedAttempts < _n.failedAttempts;
+				else
+					return rating < _n.rating;
+			else
+				return score < _n.score;
+	}
+
 	void connect(Host* _h);
 };
 
@@ -174,6 +194,8 @@ private:
 	std::shared_ptr<Node> noteNode(NodeId _id, bi::tcp::endpoint const& _a, Origin _o, bool _ready, NodeId _oldId = h256());
 	Nodes potentialPeers(RangeMask<unsigned> const& _known);
 
+	void requestPeers();
+
 	std::string m_clientVersion;											///< Our version string.
 
 	NetworkPreferences m_netPrefs;											///< Network settings.
@@ -205,8 +227,7 @@ private:
 	RangeMask<unsigned> m_ready;											///< Indices into m_nodesList over to which nodes we are not currently connected, connecting or otherwise ignoring.
 	RangeMask<unsigned> m_private;											///< Indices into m_nodesList over to which nodes are private.
 
-	std::vector<NodeId> m_freePeers;// TODO: Kill
+	std::chrono::steady_clock::time_point m_lastPeersRequest;				///< Last time we asked for some peers - don't want to do this too often. TODO: peers should be pushed, not polled.
-	std::chrono::steady_clock::time_point m_lastPeersRequest;// TODO: Kill
 
 	unsigned m_idealPeerCount = 5;											///< Ideal number of peers to be connected to.