Changeset 48fb12e


Ignore:
Timestamp:
Mar 29, 2017 12:30:21 PM (4 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
3cc0122
Parents:
82554b9
Message:

SSU: Refactor PeerTestEvent? out of UDPTransport

Location:
router/java/src/net/i2p/router/transport
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/net/i2p/router/transport/TransportImpl.java

    r82554b9 r48fb12e  
    816816     *  This returns true if the force-firewalled setting is configured, false otherwise.
    817817     *
    818      *  @since 0.9.20
    819      */
    820     protected boolean isIPv4Firewalled() {
     818     *  @since 0.9.20, public since 0.9.30
     819     */
     820    public boolean isIPv4Firewalled() {
    821821        return TransportUtil.isIPv4Firewalled(_context, getStyle());
    822822    }
     
    825825     *  This returns true if the force-firewalled setting is configured, false otherwise.
    826826     *
    827      *  @since 0.9.27
    828      */
    829     protected boolean isIPv6Firewalled() {
     827     *  @since 0.9.27, public since 0.9.30
     828     */
     829    public boolean isIPv6Firewalled() {
    830830        return TransportUtil.isIPv6Firewalled(_context, getStyle());
    831831    }
     
    988988
    989989    /**
    990      *  @since IPv6
    991      */
    992     protected TransportUtil.IPv6Config getIPv6Config() {
     990     *  @since IPv6, public since 0.9.30
     991     */
     992    public TransportUtil.IPv6Config getIPv6Config() {
    993993        return TransportUtil.getIPv6Config(_context, getStyle());
    994994    }
  • router/java/src/net/i2p/router/transport/udp/UDPTransport.java

    r82554b9 r48fb12e  
    7676    private final InboundMessageFragments _inboundFragments;
    7777    //private UDPFlooder _flooder;
    78     private PeerTestManager _testManager;
     78    private final PeerTestManager _testManager;
    7979    private final IntroductionManager _introManager;
    8080    private final ExpirePeerEvent _expireEvent;
     
    196196   
    197197    public static final int DEFAULT_COST = 5;
    198     private static final int TEST_FREQUENCY = 13*60*1000;
    199     private static final int MIN_TEST_FREQUENCY = 45*1000;
    200198    static final long[] RATES = { 10*60*1000 };
    201199    /** minimum active peers to maintain IP detection, etc. */
     
    267265        _expireTimeout = EXPIRE_TIMEOUT;
    268266        _expireEvent = new ExpirePeerEvent();
    269         _testEvent = new PeerTestEvent();
     267        _testManager = new PeerTestManager(_context, this);
     268        _testEvent = new PeerTestEvent(_context, this, _testManager);
    270269        _reachabilityStatus = Status.UNKNOWN;
    271270        _introManager = new IntroductionManager(_context, this);
     
    477476            _establisher = new EstablishmentManager(_context, this);
    478477       
    479         if (_testManager == null)
    480             _testManager = new PeerTestManager(_context, this);
    481        
    482478        if (_handler == null)
    483479            _handler = new PacketHandler(_context, this, _establisher, _inboundFragments, _testManager, _introManager);
     
    666662            return addr.getIP();
    667663        return null;
     664    }
     665
     666    /**
     667     *  For PeerTestManager
     668     *  @since 0.9.30
     669     */
     670    boolean hasIPv6Address() {
     671        return _haveIPv6Address;
    668672    }
    669673
     
    32843288    }
    32853289   
    3286     private boolean shouldTest() {
    3287         return ! (_context.router().isHidden() ||
    3288                   (isIPv4Firewalled() && isIPv6Firewalled()));
    3289         //String val = _context.getProperty(PROP_SHOULD_TEST);
    3290         //return ( (val != null) && ("true".equals(val)) );
    3291     }
    3292    
    3293     /**
    3294      *  Initiate a test (we are Alice)
    3295      */
    3296     private class PeerTestEvent extends SimpleTimer2.TimedEvent {
    3297         private boolean _alive;
    3298         /** when did we last test our reachability */
    3299         private final AtomicLong _lastTested = new AtomicLong();
    3300         private final AtomicLong _lastTestedV6 = new AtomicLong();
    3301         private static final int NO_FORCE = 0, FORCE_IPV4 = 1, FORCE_IPV6 = 2;
    3302         private int _forceRun;
    3303 
    3304         PeerTestEvent() {
    3305             super(_context.simpleTimer2());
    3306         }
    3307        
    3308         public synchronized void timeReached() {
    3309             // just for IPv6 for now
    3310             if (shouldTest()) {
    3311                 long now = _context.clock().now();
    3312                 long sinceRunV4 = now - _lastTested.get();
    3313                 long sinceRunV6 = now - _lastTestedV6.get();
    3314                 if (_forceRun == FORCE_IPV4 && sinceRunV4 >= MIN_TEST_FREQUENCY) {
    3315                     locked_runTest(false);
    3316                 } else if (_haveIPv6Address &&_forceRun == FORCE_IPV6 && sinceRunV6 >= MIN_TEST_FREQUENCY) {
    3317                     locked_runTest(true);
    3318                 } else if (sinceRunV4 >= TEST_FREQUENCY && getIPv6Config() != IPV6_ONLY) {
    3319                     locked_runTest(false);
    3320                 } else if (_haveIPv6Address && sinceRunV6 >= TEST_FREQUENCY) {
    3321                     locked_runTest(true);
    3322                 } else {
    3323                     if (_log.shouldLog(Log.INFO))
    3324                         _log.info("PTE timeReached(), no test run, last v4 test: " + new java.util.Date(_lastTested.get()) +
    3325                                   " last v6 test: " + new java.util.Date(_lastTestedV6.get()));
    3326                 }
    3327             }
    3328             if (_alive) {
    3329                 long delay = (TEST_FREQUENCY / 2) + _context.random().nextInt(TEST_FREQUENCY);
    3330                 // if we have 2 addresses, give IPv6 a chance also
    3331                 if (_haveIPv6Address && getIPv6Config() != IPV6_ONLY)
    3332                     delay /= 2;
    3333                 schedule(delay);
    3334             }
    3335         }
    3336        
    3337         private void locked_runTest(boolean isIPv6) {
    3338             PeerState bob = pickTestPeer(BOB, isIPv6, null);
    3339             if (bob != null) {
    3340                 if (_log.shouldLog(Log.INFO))
    3341                     _log.info("Running periodic test with bob = " + bob);
    3342                 _testManager.runTest(bob.getRemoteIPAddress(), bob.getRemotePort(), bob.getCurrentCipherKey(), bob.getCurrentMACKey());
    3343                 setLastTested(isIPv6);
    3344             } else {
    3345                 if (_log.shouldLog(Log.WARN))
    3346                     _log.warn("Unable to run peer test, no peers available - v6? " + isIPv6);
    3347             }
    3348             _forceRun = NO_FORCE;
    3349         }
    3350        
    3351         /**
    3352          *  Run within the next 45 seconds at the latest
    3353          *  @since 0.9.13
    3354          */
    3355         public synchronized void forceRunSoon(boolean isIPv6) {
    3356             if (!isIPv6 && isIPv4Firewalled())
    3357                 return;
    3358             if (isIPv6 && isIPv6Firewalled())
    3359                 return;
    3360             _forceRun = isIPv6 ? FORCE_IPV6 : FORCE_IPV4;
    3361             reschedule(MIN_TEST_FREQUENCY);
    3362         }
    3363        
    3364         /**
    3365          *
    3366          *  Run within the next 5 seconds at the latest
    3367          *  @since 0.9.13
    3368          */
    3369         public synchronized void forceRunImmediately(boolean isIPv6) {
    3370             if (!isIPv6 && isIPv4Firewalled())
    3371                 return;
    3372             if (isIPv6 && isIPv6Firewalled())
    3373                 return;
    3374             if (isIPv6)
    3375                 _lastTestedV6.set(0);
    3376             else
    3377                 _lastTested.set(0);
    3378             _forceRun = isIPv6 ? FORCE_IPV6 : FORCE_IPV4;
    3379             reschedule(5*1000);
    3380         }
    3381        
    3382         public synchronized void setIsAlive(boolean isAlive) {
    3383             _alive = isAlive;
    3384             if (isAlive) {
    3385                 long delay = _context.random().nextInt(2*TEST_FREQUENCY);
    3386                 reschedule(delay);
    3387             } else {
    3388                 cancel();
    3389             }
    3390         }
    3391 
    3392         /**
    3393          *  Set the last-tested timer to now
    3394          *  @since 0.9.13
    3395          */
    3396         public void setLastTested(boolean isIPv6) {
    3397             // do not synchronize - deadlock with PeerTestManager
    3398             long now = _context.clock().now();
    3399             if (isIPv6)
    3400                 _lastTestedV6.set(now);
    3401             else
    3402                 _lastTested.set(now);
    3403             if (_log.shouldLog(Log.DEBUG))
    3404                 _log.debug("PTE.setLastTested() - v6? " + isIPv6, new Exception());
    3405         }
    3406        
    3407     }
    3408    
    34093290    /**
    34103291     *  Periodically ping the introducers, split out since we need to
Note: See TracChangeset for help on using the changeset viewer.