* 2006-04-15 0.6.1.16 released

2006-04-15 jrandom
* Adjust the proactive tunnel request dropping so we will reject what we can instead of dropping so much (but still dropping if we get too far overloaded)
2006-04-15 07:58:12 +00:00 · 2006-04-15 07:15:19 +00:00 · 2006-04-14 20:24:07 +00:00 · 2006-04-14 18:04:11 +00:00 · 2006-04-14 11:40:35 +00:00
12 changed files with 115 additions and 40 deletions
--- a/core/java/src/net/i2p/CoreVersion.java
+++ b/core/java/src/net/i2p/CoreVersion.java
@ -14,8 +14,8 @@ package net.i2p;
 *
 */
 public class CoreVersion {
-    public final static String ID = "$Revision: 1.57 $ $Date: 2006/04/05 12:08:07 $";
-    public final static String VERSION = "0.6.1.15";
+    public final static String ID = "$Revision: 1.58 $ $Date: 2006/04/13 07:40:21 $";
+    public final static String VERSION = "0.6.1.16";

    public static void main(String args[]) {
        System.out.println("I2P Core version: " + VERSION);
--- a/core/java/src/net/i2p/util/FortunaRandomSource.java
+++ b/core/java/src/net/i2p/util/FortunaRandomSource.java
@ -157,11 +157,16 @@ public class FortunaRandomSource extends RandomSource implements EntropyHarveste
     * through 2^numBits-1
     */
    protected synchronized int nextBits(int numBits) {
-        int rv = 0;
+        long rv = 0;
        int bytes = (numBits + 7) / 8;
        for (int i = 0; i < bytes; i++)
            rv += ((_fortuna.nextByte() & 0xFF) << i*8);
-        return rv;
+        //rv >>>= (64-numBits);
+        if (rv < 0)
+            rv = 0 - rv;
+        int off = 8*bytes - numBits;
+        rv >>>= off;
+        return (int)rv;
    }
    
    public EntropyHarvester harvester() { return this; }
--- a/history.txt
+++ b/history.txt
@ -1,4 +1,23 @@
-$Id: history.txt,v 1.454 2006/04/12 23:22:07 jrandom Exp $
+$Id: history.txt,v 1.459 2006/04/15 02:15:19 jrandom Exp $
+
+* 2006-04-15  0.6.1.16 released
+
+2006-04-15  jrandom
+    * Adjust the proactive tunnel request dropping so we will reject what we
+      can instead of dropping so much (but still dropping if we get too far
+      overloaded)
+
+2006-04-14  jrandom
+    * 0 isn't very random
+    * Adjust the tunnel drop to be more reasonable
+
+2006-04-14  jrandom
+    * -28.00230115311259 is not between 0 and 1 in any universe I know.
+    * Made the bw-related tunnel join throttle much simpler
+
+2006-04-14  jrandom
+    * Make some more stats graphable, and allow some internal tweaking on the
+      tunnel pairing for creation and testing.

 * 2006-04-13  0.6.1.15 released

--- a/initialNews.xml
+++ b/initialNews.xml
@ -1,5 +1,5 @@
-<i2p.news date="$Date: 2006/04/05 12:08:05 $">
- <i2p.release version="0.6.1.15" date="2006/04/13" minVersion="0.6"
+<i2p.news date="$Date: 2006/04/13 07:40:21 $">
+ <i2p.release version="0.6.1.16" date="2006/04/15" minVersion="0.6"
              anonurl="http://i2p/NF2RLVUxVulR3IqK0sGJR0dHQcGXAzwa6rEO4WAWYXOHw-DoZhKnlbf1nzHXwMEJoex5nFTyiNMqxJMWlY54cvU~UenZdkyQQeUSBZXyuSweflUXFqKN-y8xIoK2w9Ylq1k8IcrAFDsITyOzjUKoOPfVq34rKNDo7fYyis4kT5bAHy~2N1EVMs34pi2RFabATIOBk38Qhab57Umpa6yEoE~rbyR~suDRvD7gjBvBiIKFqhFueXsR2uSrPB-yzwAGofTXuklofK3DdKspciclTVzqbDjsk5UXfu2nTrC1agkhLyqlOfjhyqC~t1IXm-Vs2o7911k7KKLGjB4lmH508YJ7G9fLAUyjuB-wwwhejoWqvg7oWvqo4oIok8LG6ECR71C3dzCvIjY2QcrhoaazA9G4zcGMm6NKND-H4XY6tUWhpB~5GefB3YczOqMbHq4wi0O9MzBFrOJEOs3X4hwboKWANf7DT5PZKJZ5KorQPsYRSq0E3wSOsFCSsdVCKUGsAAAA/i2p/i2pupdate.sud"
              publicurl="http://dev.i2p.net/i2p/i2pupdate.sud"
              anonannouncement="http://i2p/NF2RLVUxVulR3IqK0sGJR0dHQcGXAzwa6rEO4WAWYXOHw-DoZhKnlbf1nzHXwMEJoex5nFTyiNMqxJMWlY54cvU~UenZdkyQQeUSBZXyuSweflUXFqKN-y8xIoK2w9Ylq1k8IcrAFDsITyOzjUKoOPfVq34rKNDo7fYyis4kT5bAHy~2N1EVMs34pi2RFabATIOBk38Qhab57Umpa6yEoE~rbyR~suDRvD7gjBvBiIKFqhFueXsR2uSrPB-yzwAGofTXuklofK3DdKspciclTVzqbDjsk5UXfu2nTrC1agkhLyqlOfjhyqC~t1IXm-Vs2o7911k7KKLGjB4lmH508YJ7G9fLAUyjuB-wwwhejoWqvg7oWvqo4oIok8LG6ECR71C3dzCvIjY2QcrhoaazA9G4zcGMm6NKND-H4XY6tUWhpB~5GefB3YczOqMbHq4wi0O9MzBFrOJEOs3X4hwboKWANf7DT5PZKJZ5KorQPsYRSq0E3wSOsFCSsdVCKUGsAAAA/pipermail/i2p/2005-September/000878.html" 
--- a/installer/install.xml
+++ b/installer/install.xml
@ -4,7 +4,7 @@

    <info>
        <appname>i2p</appname>
-        <appversion>0.6.1.15</appversion>
+        <appversion>0.6.1.16</appversion>
        <authors>
            <author name="I2P" email="support@i2p.net"/>
        </authors>
--- a/news.xml
+++ b/news.xml
@ -1,5 +1,5 @@
-<i2p.news date="$Date: 2006/04/05 12:08:04 $">
- <i2p.release version="0.6.1.15" date="2006/04/13" minVersion="0.6"
+<i2p.news date="$Date: 2006/04/13 07:40:21 $">
+ <i2p.release version="0.6.1.16" date="2006/04/15" minVersion="0.6"
              anonurl="http://i2p/NF2RLVUxVulR3IqK0sGJR0dHQcGXAzwa6rEO4WAWYXOHw-DoZhKnlbf1nzHXwMEJoex5nFTyiNMqxJMWlY54cvU~UenZdkyQQeUSBZXyuSweflUXFqKN-y8xIoK2w9Ylq1k8IcrAFDsITyOzjUKoOPfVq34rKNDo7fYyis4kT5bAHy~2N1EVMs34pi2RFabATIOBk38Qhab57Umpa6yEoE~rbyR~suDRvD7gjBvBiIKFqhFueXsR2uSrPB-yzwAGofTXuklofK3DdKspciclTVzqbDjsk5UXfu2nTrC1agkhLyqlOfjhyqC~t1IXm-Vs2o7911k7KKLGjB4lmH508YJ7G9fLAUyjuB-wwwhejoWqvg7oWvqo4oIok8LG6ECR71C3dzCvIjY2QcrhoaazA9G4zcGMm6NKND-H4XY6tUWhpB~5GefB3YczOqMbHq4wi0O9MzBFrOJEOs3X4hwboKWANf7DT5PZKJZ5KorQPsYRSq0E3wSOsFCSsdVCKUGsAAAA/i2p/i2pupdate.sud"
              publicurl="http://dev.i2p.net/i2p/i2pupdate.sud"
              anonannouncement="http://i2p/NF2RLVUxVulR3IqK0sGJR0dHQcGXAzwa6rEO4WAWYXOHw-DoZhKnlbf1nzHXwMEJoex5nFTyiNMqxJMWlY54cvU~UenZdkyQQeUSBZXyuSweflUXFqKN-y8xIoK2w9Ylq1k8IcrAFDsITyOzjUKoOPfVq34rKNDo7fYyis4kT5bAHy~2N1EVMs34pi2RFabATIOBk38Qhab57Umpa6yEoE~rbyR~suDRvD7gjBvBiIKFqhFueXsR2uSrPB-yzwAGofTXuklofK3DdKspciclTVzqbDjsk5UXfu2nTrC1agkhLyqlOfjhyqC~t1IXm-Vs2o7911k7KKLGjB4lmH508YJ7G9fLAUyjuB-wwwhejoWqvg7oWvqo4oIok8LG6ECR71C3dzCvIjY2QcrhoaazA9G4zcGMm6NKND-H4XY6tUWhpB~5GefB3YczOqMbHq4wi0O9MzBFrOJEOs3X4hwboKWANf7DT5PZKJZ5KorQPsYRSq0E3wSOsFCSsdVCKUGsAAAA/pipermail/i2p/2005-September/000878.html" 
--- a/router/java/src/net/i2p/router/RouterThrottleImpl.java
+++ b/router/java/src/net/i2p/router/RouterThrottleImpl.java
@ -190,9 +190,16 @@ class RouterThrottleImpl implements RouterThrottle {
        // of another tunnel?
        rs = _context.statManager().getRate("tunnel.participatingMessageCount");
        r = null;
-        if (rs != null)
+        double messagesPerTunnel = DEFAULT_MESSAGES_PER_TUNNEL_ESTIMATE;
+        if (rs != null) {
            r = rs.getRate(10*60*1000);
-        double messagesPerTunnel = (r != null ? r.getAverageValue() : 0d);
+            if (r != null) {
+                if (r.getLastEventCount() > 0)
+                    messagesPerTunnel = r.getAverageValue();
+                else
+                    messagesPerTunnel = r.getLifetimeAverageValue();
+            }
+        }
        if (messagesPerTunnel < DEFAULT_MESSAGES_PER_TUNNEL_ESTIMATE)
            messagesPerTunnel = DEFAULT_MESSAGES_PER_TUNNEL_ESTIMATE;
        int participatingTunnels = _context.tunnelManager().getParticipatingCount();
@ -237,7 +244,7 @@ class RouterThrottleImpl implements RouterThrottle {
        return Math.max(send, recv);
    }
    
-    private static final int DEFAULT_MESSAGES_PER_TUNNEL_ESTIMATE = 600; // 1KBps
+    private static final int DEFAULT_MESSAGES_PER_TUNNEL_ESTIMATE = 60; // .1KBps
    private static final int MIN_AVAILABLE_BPS = 4*1024; // always leave at least 4KBps free when allowing
    
    /**
@ -248,15 +255,37 @@ class RouterThrottleImpl implements RouterThrottle {
     */
    private boolean allowTunnel(double bytesAllocated, int numTunnels) {
        int maxKBps = Math.min(_context.bandwidthLimiter().getOutboundKBytesPerSecond(), _context.bandwidthLimiter().getInboundKBytesPerSecond());
-        int used1s = get1sRate(_context); // dont throttle on the 1s rate, its too volatile
+        int used1s = 0; //get1sRate(_context); // dont throttle on the 1s rate, its too volatile
        int used1m = get1mRate(_context);
        int used5m = 0; //get5mRate(_context); // don't throttle on the 5m rate, as that'd hide available bandwidth
        int used = Math.max(Math.max(used1s, used1m), used5m);
-        int availBps = (int)(((maxKBps*1024) - used) * getSharePercentage());
+        double share = getSharePercentage();
+        int availBps = (int)(((maxKBps*1024)*share) - used); //(int)(((maxKBps*1024) - used) * getSharePercentage());

        _context.statManager().addRateData("router.throttleTunnelBytesUsed", used, maxKBps);
        _context.statManager().addRateData("router.throttleTunnelBytesAllowed", availBps, (long)bytesAllocated);

+        if (true) {
+            // ok, ignore any predictions of 'bytesAllocated', since that makes poorly
+            // grounded conclusions about future use (or even the bursty use).  Instead,
+            // simply say "do we have the bw to handle a new request"?
+            float maxBps = maxKBps * 1024f;
+            float pctFull = (maxBps - availBps) / (maxBps);
+            double probReject = Math.pow(pctFull, 16); // steep curve 
+            double rand = _context.random().nextFloat();
+            boolean reject = (availBps < MIN_AVAILABLE_BPS) || (rand <= probReject);
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("reject = " + reject + " avail/maxK/used " + availBps + "/" + maxKBps + "/" 
+                          + used + " pReject = " + probReject + " pFull = " + pctFull + " numTunnels = " + numTunnels 
+                          + "rand = " + rand + " est = " + bytesAllocated + " share = " + (float)share);
+            if (reject) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+        
+        
        /*
        if (availBps <= 8*1024) {
            // lets be more conservative for people near their limit and assume 1KBps per tunnel
@ -280,7 +309,7 @@ class RouterThrottleImpl implements RouterThrottle {
            return true;
        } else {
            double probAllow = availBps / (allocatedBps + availBps);
-            boolean allow = (availBps > MIN_AVAILABLE_BPS) && (_context.random().nextDouble() <= probAllow);
+            boolean allow = (availBps > MIN_AVAILABLE_BPS) && (_context.random().nextFloat() <= probAllow);
            if (allow) {
                if (_log.shouldLog(Log.INFO))
                    _log.info("Probabalistically allowing the tunnel w/ " + (pctFull*100d) + "% of our " + availBps 
--- a/router/java/src/net/i2p/router/RouterVersion.java
+++ b/router/java/src/net/i2p/router/RouterVersion.java
@ -15,8 +15,8 @@ import net.i2p.CoreVersion;
 *
 */
 public class RouterVersion {
-    public final static String ID = "$Revision: 1.394 $ $Date: 2006/04/12 23:22:33 $";
-    public final static String VERSION = "0.6.1.15";
+    public final static String ID = "$Revision: 1.399 $ $Date: 2006/04/15 02:15:23 $";
+    public final static String VERSION = "0.6.1.16";
    public final static long BUILD = 0;
    public static void main(String args[]) {
        System.out.println("I2P Router version: " + VERSION + "-" + BUILD);
--- a/router/java/src/net/i2p/router/transport/udp/EstablishmentManager.java
+++ b/router/java/src/net/i2p/router/transport/udp/EstablishmentManager.java
@ -62,10 +62,10 @@ public class EstablishmentManager {
        _queuedOutbound = new HashMap(32);
        _liveIntroductions = new HashMap(32);
        _activityLock = new Object();
-        _context.statManager().createRateStat("udp.inboundEstablishTime", "How long it takes for a new inbound session to be established", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("udp.outboundEstablishTime", "How long it takes for a new outbound session to be established", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("udp.inboundEstablishFailedState", "What state a failed inbound establishment request fails in", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("udp.outboundEstablishFailedState", "What state a failed outbound establishment request fails in", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("udp.inboundEstablishTime", "How long it takes for a new inbound session to be established", "udp", new long[] { 60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("udp.outboundEstablishTime", "How long it takes for a new outbound session to be established", "udp", new long[] { 60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("udp.inboundEstablishFailedState", "What state a failed inbound establishment request fails in", "udp", new long[] { 60*1000, 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("udp.outboundEstablishFailedState", "What state a failed outbound establishment request fails in", "udp", new long[] { 60*1000, 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.sendIntroRelayRequest", "How often we send a relay request to reach a peer", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.sendIntroRelayTimeout", "How often a relay request times out before getting a response (due to the target or intro peer being offline)", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.receiveIntroRelayResponse", "How long it took to receive a relay response", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
--- a/router/java/src/net/i2p/router/transport/udp/UDPTransport.java
+++ b/router/java/src/net/i2p/router/transport/udp/UDPTransport.java
@ -154,7 +154,7 @@ public class UDPTransport extends TransportImpl implements TimedWeightedPriority
        
        _context.statManager().createRateStat("udp.alreadyConnected", "What is the lifetime of a reestablished session", "udp", new long[] { 60*1000, 10*60*1000, 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.droppedPeer", "How long ago did we receive from a dropped peer (duration == session lifetime", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
-        _context.statManager().createRateStat("udp.droppedPeerInactive", "How long ago did we receive from a dropped peer (duration == session lifetime)", "udp", new long[] { 60*60*1000, 24*60*60*1000 });
+        _context.statManager().createRateStat("udp.droppedPeerInactive", "How long ago did we receive from a dropped peer (duration == session lifetime)", "udp", new long[] { 60*1000, 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.statusOK", "How many times the peer test returned OK", "udp", new long[] { 5*60*1000, 20*60*1000, 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.statusDifferent", "How many times the peer test returned different IP/ports", "udp", new long[] { 5*60*1000, 20*60*1000, 60*60*1000, 24*60*60*1000 });
        _context.statManager().createRateStat("udp.statusReject", "How many times the peer test returned reject unsolicited", "udp", new long[] { 5*60*1000, 20*60*1000, 60*60*1000, 24*60*60*1000 });
--- a/router/java/src/net/i2p/router/tunnel/pool/BuildHandler.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/BuildHandler.java
@ -49,6 +49,7 @@ class BuildHandler {
        _context.statManager().createRateStat("tunnel.dropLoadDelay", "How long we had to wait before finally giving up on an inbound request?", "Tunnels", new long[] { 60*1000, 10*60*1000 });
        _context.statManager().createRateStat("tunnel.dropLoadBacklog", "How many requests were pending when they were so lagged that we had to drop a new inbound request??", "Tunnels", new long[] { 60*1000, 10*60*1000 });
        _context.statManager().createRateStat("tunnel.dropLoadProactive", "What the estimated queue time was when we dropped an inbound request (period is num pending)", "Tunnels", new long[] { 60*1000, 10*60*1000 });
+        _context.statManager().createRateStat("tunnel.dropLoadProactiveAbort", "How often we would have proactively dropped a request, but allowed it through?", "Tunnels", new long[] { 60*1000, 10*60*1000 });
        _context.statManager().createRateStat("tunnel.handleRemaining", "How many pending inbound requests were left on the queue after one pass?", "Tunnels", new long[] { 60*1000, 10*60*1000 });
        
        _context.statManager().createRateStat("tunnel.receiveRejectionProbabalistic", "How often we are rejected probabalistically?", "Tunnels", new long[] { 10*60*1000l, 60*60*1000l, 24*60*60*1000l });
@ -371,7 +372,7 @@ class BuildHandler {
     * If we are dropping lots of requests before even trying to handle them,
     * I suppose you could call us "overloaded"
     */
-    private final static int MAX_PROACTIVE_DROPS = 120;
+    private final static int MAX_PROACTIVE_DROPS = 240;
    
    private int countProactiveDrops() {
        int dropped = 0;
@ -413,14 +414,18 @@ class BuildHandler {
        
        int proactiveDrops = countProactiveDrops();
        long recvDelay = System.currentTimeMillis()-state.recvTime;
-        if ( (response == 0) && ( (recvDelay > BuildRequestor.REQUEST_TIMEOUT/2) || (proactiveDrops > MAX_PROACTIVE_DROPS) ) ) {
-            _context.statManager().addRateData("tunnel.rejectOverloaded", recvDelay, proactiveDrops);
-            if (true || (proactiveDrops < MAX_PROACTIVE_DROPS*2))
-                response = TunnelHistory.TUNNEL_REJECT_TRANSIENT_OVERLOAD;
-            else
-                response = TunnelHistory.TUNNEL_REJECT_BANDWIDTH;
-        } else if (response == 0) {
-            _context.statManager().addRateData("tunnel.acceptLoad", recvDelay, recvDelay);
+        if (response == 0) {
+            float pDrop = recvDelay / (BuildRequestor.REQUEST_TIMEOUT/2);
+            pDrop = (float)Math.pow(pDrop, 16);
+            if (_context.random().nextFloat() < pDrop) { // || (proactiveDrops > MAX_PROACTIVE_DROPS) ) ) {
+                _context.statManager().addRateData("tunnel.rejectOverloaded", recvDelay, proactiveDrops);
+                if (true || (proactiveDrops < MAX_PROACTIVE_DROPS*2))
+                    response = TunnelHistory.TUNNEL_REJECT_TRANSIENT_OVERLOAD;
+                else
+                    response = TunnelHistory.TUNNEL_REJECT_BANDWIDTH;
+            } else {
+                _context.statManager().addRateData("tunnel.acceptLoad", recvDelay, recvDelay);
+            }
        }
        
        if (_log.shouldLog(Log.DEBUG))
@ -604,9 +609,9 @@ class BuildHandler {
                        } else {
                            int queueTime = estimateQueueTime(_inboundBuildMessages.size());
                            float pDrop = queueTime/((float)BuildRequestor.REQUEST_TIMEOUT/2);
-                            pDrop = pDrop * pDrop;
+                            pDrop = (float)Math.pow(pDrop, 16); // steeeep
                            float f = _context.random().nextFloat();
-                            if (pDrop > f) {
+                            if ( (pDrop > f) && (allowProactiveDrop()) ) {
                                _context.statManager().addRateData("tunnel.dropLoadProactive", queueTime, _inboundBuildMessages.size());
                            } else {
                                _inboundBuildMessages.add(new BuildMessageState(receivedMessage, from, fromHash));
@ -620,6 +625,16 @@ class BuildHandler {
        }
    }
    
+    private boolean allowProactiveDrop() {
+        String allow = _context.getProperty("router.allowProactiveDrop", "true");
+        boolean rv = false;
+        if ( (allow == null) || (Boolean.valueOf(allow).booleanValue()) )
+            rv = true;
+        if (!rv)
+            _context.statManager().addRateData("tunnel.dropLoadProactiveAbort", 1, 0);
+        return rv;
+    }
+    
    private int estimateQueueTime(int numPendingMessages) {
        int decryptTime = 200;
        RateStat rs = _context.statManager().getRate("crypto.elGamal.decrypt");
@ -636,9 +651,9 @@ class BuildHandler {
                    decryptTime = (int)avg;
            }
        }
-        int estimatedQueueTime = numPendingMessages * decryptTime;
-        estimatedQueueTime *= 2; // lets leave some cpu to spare, 'eh?
-        return estimatedQueueTime;
+        float estimatedQueueTime = numPendingMessages * decryptTime;
+        estimatedQueueTime *= 1.2f; // lets leave some cpu to spare, 'eh?
+        return (int)estimatedQueueTime;
    }
    
    
--- a/router/java/src/net/i2p/router/tunnel/pool/BuildRequestor.java
+++ b/router/java/src/net/i2p/router/tunnel/pool/BuildRequestor.java
@ -21,10 +21,17 @@ class BuildRequestor {
        for (int i = 0; i < BuildMessageGenerator.ORDER.length; i++)
            ORDER.add(new Integer(i));
    }
-    private static final boolean USE_PAIRED_CLIENT_TUNNELS = true;
    private static final int PRIORITY = 500;
    static final int REQUEST_TIMEOUT = 20*1000;
    
+    private static boolean usePairedTunnels(RouterContext ctx) {
+        String val = ctx.getProperty("router.usePairedTunnels");
+        if ( (val == null) || (Boolean.valueOf(val).booleanValue()) )
+            return true;
+        else
+            return false;
+    }
+    
    /** new style requests need to fill in the tunnel IDs before hand */
    public static void prepare(RouterContext ctx, PooledTunnelCreatorConfig cfg) {
        for (int i = 0; i < cfg.getLength(); i++) {
@ -58,7 +65,7 @@ class BuildRequestor {
        cfg.setTunnelPool(pool);
        
        TunnelInfo pairedTunnel = null;
-        if (pool.getSettings().isExploratory() || !USE_PAIRED_CLIENT_TUNNELS) {
+        if (pool.getSettings().isExploratory() || !usePairedTunnels(ctx)) {
            if (pool.getSettings().isInbound())
                pairedTunnel = ctx.tunnelManager().selectOutboundTunnel();
            else
@ -72,7 +79,7 @@ class BuildRequestor {
        if (pairedTunnel == null) {   
            if (log.shouldLog(Log.WARN))
                log.warn("Couldn't find a paired tunnel for " + cfg + ", fall back on exploratory tunnels for pairing");
-            if (!pool.getSettings().isExploratory() && USE_PAIRED_CLIENT_TUNNELS)
+            if (!pool.getSettings().isExploratory() && usePairedTunnels(ctx))
                if (pool.getSettings().isInbound())
                    pairedTunnel = ctx.tunnelManager().selectOutboundTunnel();
                else
Author	SHA1	Message	Date
jrandom	181275fe35	* 2006-04-15 0.6.1.16 released	2006-04-15 07:58:12 +00:00
jrandom	23d8c01ce7	2006-04-15 jrandom * Adjust the proactive tunnel request dropping so we will reject what we can instead of dropping so much (but still dropping if we get too far overloaded)	2006-04-15 07:15:19 +00:00
jrandom	de83944486	2006-04-14 jrandom * 0 isn't very random * Adjust the tunnel drop to be more reasonable	2006-04-14 20:24:07 +00:00
jrandom	90cd7ff23a	2006-04-14 jrandom * -28.00230115311259 is not between 0 and 1 in any universe I know. * Made the bw-related tunnel join throttle much simpler	2006-04-14 18:04:11 +00:00
jrandom	8d0a9b4ccd	2006-04-14 jrandom * Make some more stats graphable, and allow some internal tweaking on the tunnel pairing for creation and testing.	2006-04-14 11:40:35 +00:00