From 829e3f47ffb36e90f102af71d93baaf231a2845e Mon Sep 17 00:00:00 2001
From: zzz <zzz@mail.i2p>
Date: Thu, 21 Jun 2012 20:52:39 +0000
Subject: [PATCH] Store context in the PeerSelector so we don't have to pass it
around
---
.../tunnel/pool/ClientPeerSelector.java | 19 +++++++---
.../tunnel/pool/ExploratoryPeerSelector.java | 35 +++++++++++--------
.../tunnel/pool/TunnelPeerSelector.java | 18 ++++++----
.../i2p/router/tunnel/pool/TunnelPool.java | 2 +-
.../router/tunnel/pool/TunnelPoolManager.java | 4 +--
5 files changed, 50 insertions(+), 28 deletions(-)
diff --git a/router/java/src/net/i2p/router/tunnel/pool/ClientPeerSelector.java b/router/java/src/net/i2p/router/tunnel/pool/ClientPeerSelector.java
index 24e6966a12..468cacaf26 100644
--- a/router/java/src/net/i2p/router/tunnel/pool/ClientPeerSelector.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/ClientPeerSelector.java
@@ -15,8 +15,13 @@ import net.i2p.router.TunnelPoolSettings;
*
*/
class ClientPeerSelector extends TunnelPeerSelector {
- public List<Hash> selectPeers(RouterContext ctx, TunnelPoolSettings settings) {
- int length = getLength(ctx, settings);
+
+ public ClientPeerSelector(RouterContext context) {
+ super(context);
+ }
+
+ public List<Hash> selectPeers(TunnelPoolSettings settings) {
+ int length = getLength(settings);
if (length < 0)
return null;
if ( (length == 0) && (settings.getLength()+settings.getLengthVariance() > 0) )
@@ -26,9 +31,9 @@ class ClientPeerSelector extends TunnelPeerSelector {
if (length > 0) {
if (shouldSelectExplicit(settings))
- return selectExplicit(ctx, settings, length);
+ return selectExplicit(settings, length);
- Set<Hash> exclude = getExclude(ctx, settings.isInbound(), settings.isExploratory());
+ Set<Hash> exclude = getExclude(settings.isInbound(), false);
Set<Hash> matches = new HashSet(length);
if (length == 1) {
ctx.profileOrganizer().selectFastPeers(length, exclude, matches, 0);
@@ -41,6 +46,9 @@ class ClientPeerSelector extends TunnelPeerSelector {
rv = new ArrayList(length + 1);
// OBEP or IB last hop
// group 0 or 1 if two hops, otherwise group 0
+ if (!settings.isInbound()) {
+ // exclude existing OBEPs to get some diversity
+ }
ctx.profileOrganizer().selectFastPeers(1, exclude, matches, settings.getRandomKey(), length == 2 ? 2 : 4);
matches.remove(ctx.routerHash());
exclude.addAll(matches);
@@ -64,6 +72,9 @@ class ClientPeerSelector extends TunnelPeerSelector {
}
// IBGW or OB first hop
// group 2 or 3 if two hops, otherwise group 1
+ if (settings.isInbound()) {
+ // exclude existing IBGWs to get some diversity
+ }
ctx.profileOrganizer().selectFastPeers(1, exclude, matches, settings.getRandomKey(), length == 2 ? 3 : 5);
matches.remove(ctx.routerHash());
rv.addAll(matches);
diff --git a/router/java/src/net/i2p/router/tunnel/pool/ExploratoryPeerSelector.java b/router/java/src/net/i2p/router/tunnel/pool/ExploratoryPeerSelector.java
index 1f05727dc5..ed3837ec44 100644
--- a/router/java/src/net/i2p/router/tunnel/pool/ExploratoryPeerSelector.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/ExploratoryPeerSelector.java
@@ -18,9 +18,14 @@ import net.i2p.util.Log;
*
*/
class ExploratoryPeerSelector extends TunnelPeerSelector {
- public List<Hash> selectPeers(RouterContext ctx, TunnelPoolSettings settings) {
+
+ public ExploratoryPeerSelector(RouterContext context) {
+ super(context);
+ }
+
+ public List<Hash> selectPeers(TunnelPoolSettings settings) {
Log l = ctx.logManager().getLog(getClass());
- int length = getLength(ctx, settings);
+ int length = getLength(settings);
if (length < 0) {
if (l.shouldLog(Log.DEBUG))
l.debug("Length requested is zero: " + settings);
@@ -28,13 +33,13 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
}
if (false && shouldSelectExplicit(settings)) {
- List rv = selectExplicit(ctx, settings, length);
+ List rv = selectExplicit(settings, length);
if (l.shouldLog(Log.DEBUG))
l.debug("Explicit peers selected: " + rv);
return rv;
}
- Set<Hash> exclude = getExclude(ctx, settings.isInbound(), settings.isExploratory());
+ Set<Hash> exclude = getExclude(settings.isInbound(), true);
exclude.add(ctx.routerHash());
// Don't use ff peers for exploratory tunnels to lessen exposure to netDb searches and stores
// Hmm if they don't get explored they don't get a speed/capacity rating
@@ -42,7 +47,7 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
// FloodfillNetworkDatabaseFacade fac = (FloodfillNetworkDatabaseFacade)ctx.netDb();
// exclude.addAll(fac.getFloodfillPeers());
HashSet matches = new HashSet(length);
- boolean exploreHighCap = shouldPickHighCap(ctx);
+ boolean exploreHighCap = shouldPickHighCap();
//
// We don't honor IP Restriction here, to be fixed
@@ -84,7 +89,7 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
* build success rate is much worse, return true so that reliability
* is maintained.
*/
- private static boolean shouldPickHighCap(RouterContext ctx) {
+ private boolean shouldPickHighCap() {
if (ctx.getBooleanProperty("router.exploreHighCapacity"))
return true;
@@ -118,7 +123,7 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
if (ctx.router().getUptime() <= 11*60*1000) {
failPct = 100 - MIN_NONFAILING_PCT;
} else {
- failPct = getExploratoryFailPercentage(ctx);
+ failPct = getExploratoryFailPercentage();
//Log l = ctx.logManager().getLog(getClass());
//if (l.shouldLog(Log.DEBUG))
// l.debug("Normalized Fail pct: " + failPct);
@@ -140,9 +145,9 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
* Even this isn't the "true" rate for the NonFailingPeers pool, since we
* are often building exploratory tunnels using the HighCapacity pool.
*/
- private static int getExploratoryFailPercentage(RouterContext ctx) {
- int c = getFailPercentage(ctx, "Client");
- int e = getFailPercentage(ctx, "Exploratory");
+ private int getExploratoryFailPercentage() {
+ int c = getFailPercentage("Client");
+ int e = getFailPercentage("Exploratory");
//Log l = ctx.logManager().getLog(getClass());
//if (l.shouldLog(Log.DEBUG))
// l.debug("Client, Expl. Fail pct: " + c + ", " + e);
@@ -154,11 +159,11 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
return (100 * (e-c)) / (100-c);
}
- private static int getFailPercentage(RouterContext ctx, String t) {
+ private int getFailPercentage(String t) {
String pfx = "tunnel.build" + t;
- int timeout = getEvents(ctx, pfx + "Expire", 10*60*1000);
- int reject = getEvents(ctx, pfx + "Reject", 10*60*1000);
- int accept = getEvents(ctx, pfx + "Success", 10*60*1000);
+ int timeout = getEvents(pfx + "Expire", 10*60*1000);
+ int reject = getEvents(pfx + "Reject", 10*60*1000);
+ int accept = getEvents(pfx + "Success", 10*60*1000);
if (accept + reject + timeout <= 0)
return 0;
double pct = (double)(reject + timeout) / (accept + reject + timeout);
@@ -166,7 +171,7 @@ class ExploratoryPeerSelector extends TunnelPeerSelector {
}
/** Use current + last to get more recent and smoother data */
- private static int getEvents(RouterContext ctx, String stat, long period) {
+ private int getEvents(String stat, long period) {
RateStat rs = ctx.statManager().getRate(stat);
if (rs == null)
return 0;
diff --git a/router/java/src/net/i2p/router/tunnel/pool/TunnelPeerSelector.java b/router/java/src/net/i2p/router/tunnel/pool/TunnelPeerSelector.java
index 22508a2ce9..7679ed955c 100644
--- a/router/java/src/net/i2p/router/tunnel/pool/TunnelPeerSelector.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/TunnelPeerSelector.java
@@ -31,6 +31,12 @@ import net.i2p.util.VersionComparator;
* Todo: there's nothing non-static in here
*/
public abstract class TunnelPeerSelector {
+ protected final RouterContext ctx;
+
+ protected TunnelPeerSelector(RouterContext context) {
+ ctx = context;
+ }
+
/**
* Which peers should go into the next tunnel for the given settings?
*
@@ -40,12 +46,12 @@ public abstract class TunnelPeerSelector {
* to build through, and the settings reject 0 hop tunnels, this will
* return null.
*/
- public abstract List<Hash> selectPeers(RouterContext ctx, TunnelPoolSettings settings);
+ public abstract List<Hash> selectPeers(TunnelPoolSettings settings);
/**
* @return randomized number of hops 0-7, not including ourselves
*/
- protected int getLength(RouterContext ctx, TunnelPoolSettings settings) {
+ protected int getLength(TunnelPoolSettings settings) {
int length = settings.getLength();
int override = settings.getLengthOverride();
if (override >= 0) {
@@ -109,7 +115,7 @@ public abstract class TunnelPeerSelector {
* Needs analysis and testing
* @return should always be false
*/
- protected List<Hash> selectExplicit(RouterContext ctx, TunnelPoolSettings settings, int length) {
+ protected List<Hash> selectExplicit(TunnelPoolSettings settings, int length) {
String peers = null;
Properties opts = settings.getUnknownOptions();
if (opts != null)
@@ -173,7 +179,7 @@ public abstract class TunnelPeerSelector {
/**
* Pick peers that we want to avoid
*/
- public Set<Hash> getExclude(RouterContext ctx, boolean isInbound, boolean isExploratory) {
+ public Set<Hash> getExclude(boolean isInbound, boolean isExploratory) {
// we may want to update this to skip 'hidden' or 'unreachable' peers, but that
// isn't safe, since they may publish one set of routerInfo to us and another to
// other peers. the defaults for filterUnreachable has always been to return false,
@@ -196,7 +202,7 @@ public abstract class TunnelPeerSelector {
peers.addAll(ctx.profileOrganizer().selectPeersRecentlyRejecting());
peers.addAll(ctx.tunnelManager().selectPeersInTooManyTunnels());
// if (false && filterUnreachable(ctx, isInbound, isExploratory)) {
- if (filterUnreachable(ctx, isInbound, isExploratory)) {
+ if (filterUnreachable(isInbound, isExploratory)) {
// NOTE: filterUnreachable returns true for inbound, false for outbound
// This is the only use for getPeersByCapability? And the whole set of datastructures in PeerManager?
Collection<Hash> caps = ctx.peerManager().getPeersByCapability(Router.CAPABILITY_UNREACHABLE);
@@ -439,7 +445,7 @@ public abstract class TunnelPeerSelector {
* do we want to skip peers who haven't been up for long?
* @return true for inbound, false for outbound, unless configured otherwise
*/
- protected boolean filterUnreachable(RouterContext ctx, boolean isInbound, boolean isExploratory) {
+ protected boolean filterUnreachable(boolean isInbound, boolean isExploratory) {
boolean def = false;
String val = null;
diff --git a/router/java/src/net/i2p/router/tunnel/pool/TunnelPool.java b/router/java/src/net/i2p/router/tunnel/pool/TunnelPool.java
index 9bb01fd38a..1668ecb05b 100644
--- a/router/java/src/net/i2p/router/tunnel/pool/TunnelPool.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/TunnelPool.java
@@ -1093,7 +1093,7 @@ public class TunnelPool {
}
if (peers == null) {
setLengthOverride();
- peers = _peerSelector.selectPeers(_context, settings);
+ peers = _peerSelector.selectPeers(settings);
}
if ( (peers == null) || (peers.isEmpty()) ) {
diff --git a/router/java/src/net/i2p/router/tunnel/pool/TunnelPoolManager.java b/router/java/src/net/i2p/router/tunnel/pool/TunnelPoolManager.java
index 66080501ca..a849647410 100644
--- a/router/java/src/net/i2p/router/tunnel/pool/TunnelPoolManager.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/TunnelPoolManager.java
@@ -61,7 +61,7 @@ public class TunnelPoolManager implements TunnelManagerFacade {
_clientInboundPools = new ConcurrentHashMap(4);
_clientOutboundPools = new ConcurrentHashMap(4);
- _clientPeerSelector = new ClientPeerSelector();
+ _clientPeerSelector = new ClientPeerSelector(ctx);
_executor = new BuildExecutor(ctx, this);
I2PThread execThread = new I2PThread(_executor, "BuildExecutor", true);
@@ -511,7 +511,7 @@ public class TunnelPoolManager implements TunnelManagerFacade {
t.setDaemon(true);
t.start();
}
- ExploratoryPeerSelector selector = new ExploratoryPeerSelector();
+ ExploratoryPeerSelector selector = new ExploratoryPeerSelector(_context);
TunnelPoolSettings inboundSettings = new TunnelPoolSettings();
inboundSettings.setIsExploratory(true);
--
GitLab