Changeset adcd1e8


Ignore:
Timestamp:
Mar 22, 2012 7:47:44 PM (8 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
db42a46c
Parents:
ca57b712
Message:
  • Reseeder: Get rid of static instance, root in netDB,

don't use system properties for status

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • apps/routerconsole/java/src/net/i2p/router/web/ConfigReseedHandler.java

    rca57b712 radcd1e8  
    2121        if (_action.equals(_("Save changes and reseed now"))) {
    2222            saveChanges();
    23             boolean reseedInProgress = Boolean.valueOf(System.getProperty("net.i2p.router.web.ReseedHandler.reseedInProgress")).booleanValue();
    24             if (reseedInProgress) {
     23            if (!_context.netDb().reseedChecker().requestReseed()) {
    2524                addFormError(_("Reseeding is already in progress"));
    2625            } else {
    2726                // skip the nonce checking in ReseedHandler
    2827                addFormNotice(_("Starting reseed process"));
    29                 (new ReseedHandler(_context)).requestReseed();
    3028            }
    3129            return;
     
    7573        saveBoolean(Reseeder.PROP_SPROXY_AUTH_ENABLE, "sauth");
    7674        String url = getJettyString("reseedURL");
    77         if (url != null)
    78             changes.put(Reseeder.PROP_RESEED_URL, url.trim().replace("\r\n", ",").replace("\n", ","));
     75        if (url != null) {
     76            url = url.trim().replace("\r\n", ",").replace("\n", ",");
     77            if (url.length() <= 0) {
     78                addFormNotice("Restoring default URLs");
     79                removes.add(Reseeder.PROP_RESEED_URL);
     80            } else {
     81                changes.put(Reseeder.PROP_RESEED_URL, url);
     82            }
     83        }
    7984        String mode = getJettyString("mode");
    8085        boolean req = "1".equals(mode);
  • apps/routerconsole/java/src/net/i2p/router/web/ReseedHandler.java

    rca57b712 radcd1e8  
    2525    }
    2626   
    27     public void requestReseed() {
    28         synchronized (ReseedHandler.class) {
    29             if (_reseedRunner == null)
    30                 _reseedRunner = new Reseeder(_context);
    31             _reseedRunner.requestReseed();
    32         }
     27    private void requestReseed() {
     28        _context.netDb().reseedChecker().requestReseed();
    3329    }
    3430}
  • apps/routerconsole/java/src/net/i2p/router/web/SummaryHelper.java

    rca57b712 radcd1e8  
    677677        }
    678678
    679         boolean reseedInProgress = Boolean.valueOf(System.getProperty("net.i2p.router.web.ReseedHandler.reseedInProgress")).booleanValue();
     679        boolean reseedInProgress = _context.netDb().reseedChecker().inProgress();
    680680        // If showing the reseed link is allowed
    681681        if (allowReseed()) {
    682682            if (reseedInProgress) {
    683683                // While reseed occurring, show status message instead
    684                 buf.append("<i>").append(System.getProperty("net.i2p.router.web.ReseedHandler.statusMessage","")).append("</i><br>");
     684                buf.append("<i>").append(_context.netDb().reseedChecker().getStatus()).append("</i><br>");
    685685            } else {
    686686                // While no reseed occurring, show reseed link
     
    697697        // If a new reseed ain't running, and the last reseed had errors, show error message
    698698        if (!reseedInProgress) {
    699             String reseedErrorMessage = System.getProperty("net.i2p.router.web.ReseedHandler.errorMessage","");
     699            String reseedErrorMessage = _context.netDb().reseedChecker().getError();
    700700            if (reseedErrorMessage.length() > 0) {
    701701                buf.append("<i>").append(reseedErrorMessage).append("</i><br>");
  • router/java/src/net/i2p/router/NetworkDatabaseFacade.java

    rca57b712 radcd1e8  
    1818import net.i2p.data.LeaseSet;
    1919import net.i2p.data.RouterInfo;
     20import net.i2p.router.networkdb.reseed.ReseedChecker;
    2021
    2122/**
     
    7475    /** public for NetDbRenderer in routerconsole */
    7576    public Set<RouterInfo> getRouters() { return Collections.EMPTY_SET; }
     77
     78    /** @since 0.9 */
     79    public ReseedChecker reseedChecker() { return null; };
    7680}
  • router/java/src/net/i2p/router/networkdb/kademlia/KademliaNetworkDatabaseFacade.java

    rca57b712 radcd1e8  
    4343import net.i2p.router.networkdb.DatabaseStoreMessageHandler;
    4444import net.i2p.router.networkdb.PublishLocalRouterInfoJob;
     45import net.i2p.router.networkdb.reseed.ReseedChecker;
    4546import net.i2p.router.peermanager.PeerProfile;
    4647import net.i2p.util.ConcurrentHashSet;
     
    6869    protected final PeerSelector _peerSelector;
    6970    protected final RouterContext _context;
     71    private final ReseedChecker _reseedChecker;
     72
    7073    /**
    7174     * Map of Hash to RepublishLeaseSetJob for leases we'realready managing.
     
    147150        _activeRequests = new HashMap(8);
    148151        _enforceNetId = DEFAULT_ENFORCE_NETID;
     152        _reseedChecker = new ReseedChecker(context);
    149153        context.statManager().createRateStat("netDb.lookupLeaseSetDeferred", "how many lookups are deferred for a single leaseSet lookup?", "NetworkDatabase", new long[] { 60*60*1000 });
    150154        context.statManager().createRateStat("netDb.exploreKeySet", "how many keys are queued for exploration?", "NetworkDatabase", new long[] { 60*60*1000 });
     
    168172    public PeerSelector getPeerSelector() { return _peerSelector; }
    169173   
     174    /** @since 0.9 */
     175    @Override
     176    public ReseedChecker reseedChecker() {
     177        return _reseedChecker;
     178    }
     179
    170180    KBucketSet getKBuckets() { return _kb; }
    171181    DataStore getDataStore() { return _ds; }
  • router/java/src/net/i2p/router/networkdb/kademlia/PersistentDataStore.java

    rca57b712 radcd1e8  
    383383           
    384384            if (!_alreadyWarned) {
    385                 ReseedChecker.checkReseed(_context, routerCount);
     385                _facade.reseedChecker().checkReseed(routerCount);
    386386                _alreadyWarned = true;
    387387                _initialized = true;
  • router/java/src/net/i2p/router/networkdb/reseed/ReseedChecker.java

    rca57b712 radcd1e8  
    22
    33import java.io.File;
     4import java.util.concurrent.atomic.AtomicBoolean;
    45
    56import net.i2p.router.RouterContext;
     
    2021public class ReseedChecker {
    2122   
     23    private final RouterContext _context;
     24    private final Log _log;
     25    private final AtomicBoolean _inProgress = new AtomicBoolean();
     26    private String _lastStatus = "";
     27    private String _lastError = "";
     28
    2229    private static final int MINIMUM = 15;
    2330
    24     public static void checkReseed(RouterContext context, int count) {
     31    /**
     32     *  All reseeding must be done through this instance.
     33     *  Access through context.netDb().reseedChecker(), others should not instantiate
     34     *
     35     *  @since 0.9
     36     */
     37    public ReseedChecker(RouterContext context) {
     38        _context = context;
     39        _log = context.logManager().getLog(ReseedChecker.class);
     40    }
     41
     42    /**
     43     *  Check if a reseed is needed, and start it
     44     *
     45     *  @param count current number of known routers
     46     *  @return true if a reseed was started
     47     */
     48    public boolean checkReseed(int count) {
    2549        if (count >= MINIMUM)
    26             return;
     50            return false;
     51
     52        if (_context.getBooleanProperty(Reseeder.PROP_DISABLE)) {
     53            String s = "Only " + count + " peers remaining but reseed disabled by configuration";
     54            _lastError = s;
     55            _log.logAlways(Log.WARN, s);
     56            return false;
     57        }
    2758
    2859        // we check the i2p installation directory for a flag telling us not to reseed,
     
    3162        File noReseedFile = new File(new File(System.getProperty("user.home")), ".i2pnoreseed");
    3263        File noReseedFileAlt1 = new File(new File(System.getProperty("user.home")), "noreseed.i2p");
    33         File noReseedFileAlt2 = new File(context.getConfigDir(), ".i2pnoreseed");
    34         File noReseedFileAlt3 = new File(context.getConfigDir(), "noreseed.i2p");
    35         Log _log = context.logManager().getLog(ReseedChecker.class);
     64        File noReseedFileAlt2 = new File(_context.getConfigDir(), ".i2pnoreseed");
     65        File noReseedFileAlt3 = new File(_context.getConfigDir(), "noreseed.i2p");
    3666        if (!noReseedFile.exists() && !noReseedFileAlt1.exists() && !noReseedFileAlt2.exists() && !noReseedFileAlt3.exists()) {
    3767            if (count <= 1)
     
    3969            else
    4070                _log.logAlways(Log.WARN, "Very few known peers remaining - reseeding now");
    41             Reseeder reseeder = new Reseeder(context);
    42             reseeder.requestReseed();
     71            return requestReseed();
    4372        } else {
    44             _log.logAlways(Log.WARN, "Only " + count + " peers remaining but reseed disabled by config file");
     73            String s = "Only " + count + " peers remaining but reseed disabled by config file";
     74            _lastError = s;
     75            _log.logAlways(Log.WARN, s);
     76            return false;
    4577        }
    4678    }
     79
     80    /**
     81     *  Start a reseed
     82     *
     83     *  @return true if a reseed was started, false if already in progress
     84     *  @since 0.9
     85     */
     86    public boolean requestReseed() {
     87        if (_inProgress.compareAndSet(false, true)) {
     88            try {
     89                Reseeder reseeder = new Reseeder(_context, this);
     90                reseeder.requestReseed();
     91                return true;
     92            } catch (Throwable t) {
     93                _log.error("Reseed failed to start", t);
     94                done();
     95                return false;
     96            }
     97        } else {
     98            if (_log.shouldLog(Log.WARN))
     99                _log.warn("Reseed already in prgress");
     100            return false;
     101        }
     102    }
     103
     104    /**
     105     *  Is a reseed in progress?
     106     *
     107     *  @since 0.9
     108     */
     109    public boolean inProgress() {
     110        return _inProgress.get();
     111    }
     112
     113    /**
     114     *  The reseed is complete
     115     *
     116     *  @since 0.9
     117     */
     118    void done() {
     119        _inProgress.set(false);
     120    }
     121
     122    /**
     123     *  Status from current reseed attempt,
     124     *  probably empty if no reseed in progress.
     125     *
     126     *  @return non-null, may be empty
     127     *  @since 0.9
     128     */
     129    public String getStatus() {
     130        return _lastStatus;
     131    }
     132
     133    /**
     134     *  Status from current reseed attempt
     135     *
     136     *  @param s non-null, may be empty
     137     *  @since 0.9
     138     */
     139    void setStatus(String s) {
     140        _lastStatus = s;
     141    }
     142
     143    /**
     144     *  Error from last or current reseed attempt
     145     *
     146     *  @return non-null, may be empty
     147     *  @since 0.9
     148     */
     149    public String getError() {
     150        return _lastError;
     151    }
     152
     153    /**
     154     *  Status from last or current reseed attempt
     155     *
     156     *  @param s non-null, may be empty
     157     *  @since 0.9
     158     */
     159    void setError(String s) {
     160        _lastError = s;
     161    }
     162
    47163}
  • router/java/src/net/i2p/router/networkdb/reseed/Reseeder.java

    rca57b712 radcd1e8  
    4343 */
    4444public class Reseeder {
    45     /** FIXME don't keep a static reference, store _isRunning some other way */
    46     private static ReseedRunner _reseedRunner;
    4745    private final RouterContext _context;
    4846    private final Log _log;
     47    private final ReseedChecker _checker;
    4948
    5049    // Reject unreasonably big files, because we download into a ByteArrayOutputStream.
     
    8281              "https://i2p.mooo.com/netDb/";
    8382
    84     private static final String PROP_INPROGRESS = "net.i2p.router.web.ReseedHandler.reseedInProgress";
    85     /** the console shows this message while reseedInProgress == false */
    86     private static final String PROP_ERROR = "net.i2p.router.web.ReseedHandler.errorMessage";
    87     /** the console shows this message while reseedInProgress == true */
    88     private static final String PROP_STATUS = "net.i2p.router.web.ReseedHandler.statusMessage";
    8983    public static final String PROP_PROXY_HOST = "router.reseedProxyHost";
    9084    public static final String PROP_PROXY_PORT = "router.reseedProxyPort";
     
    107101    public static final String PROP_SPROXY_PASSWORD = "router.reseedSSLProxy.password";
    108102    public static final String PROP_SPROXY_AUTH_ENABLE = "router.reseedSSLProxy.authEnable";
     103    /** @since 0.9 */
     104    public static final String PROP_DISABLE = "router.reseedDisable";
    109105
    110106    // from PersistentDataStore
     
    112108    private static final String ROUTERINFO_SUFFIX = ".dat";
    113109
    114     public Reseeder(RouterContext ctx) {
     110    Reseeder(RouterContext ctx, ReseedChecker rc) {
    115111        _context = ctx;
    116112        _log = ctx.logManager().getLog(Reseeder.class);
    117     }
    118 
    119     public void requestReseed() {
    120         synchronized (Reseeder.class) {
    121             if (_reseedRunner == null)
    122                 _reseedRunner = new ReseedRunner();
    123             if (_reseedRunner.isRunning()) {
    124                 return;
    125             } else {
    126                 // set to daemon so it doesn't hang a shutdown
    127                 Thread reseed = new I2PAppThread(_reseedRunner, "Reseed", true);
    128                 reseed.start();
    129             }
    130         }
    131 
    132     }
    133 
    134     public class ReseedRunner implements Runnable, EepGet.StatusListener {
     113        _checker = rc;
     114    }
     115
     116    void requestReseed() {
     117        ReseedRunner reseedRunner = new ReseedRunner();
     118        // set to daemon so it doesn't hang a shutdown
     119        Thread reseed = new I2PAppThread(reseedRunner, "Reseed", true);
     120        reseed.start();
     121    }
     122
     123    private class ReseedRunner implements Runnable, EepGet.StatusListener {
    135124        private boolean _isRunning;
    136125        private String _proxyHost;
     
    144133        }
    145134
    146         public boolean isRunning() { return _isRunning; }
    147 
    148135        /*
    149136         * Do it.
    150          * We update PROP_ERROR here.
    151137         */
    152138        public void run() {
     139            try {
     140                run2();
     141            } finally {
     142                _checker.done();
     143            }
     144        }
     145
     146        private void run2() {
    153147            _isRunning = true;
    154             System.clearProperty(PROP_ERROR);
    155             System.setProperty(PROP_STATUS, _("Reseeding"));
    156             System.setProperty(PROP_INPROGRESS, "true");
    157             _attemptStarted = 0;
    158             _gotDate = 0;
    159             _sslState = null;  // start fresh
     148            _checker.setError("");
     149            _checker.setStatus(_("Reseeding"));
    160150            if (_context.getBooleanProperty(PROP_PROXY_ENABLE)) {
    161151                _proxyHost = _context.getProperty(PROP_PROXY_HOST);
     
    166156            if (total >= 50) {
    167157                System.out.println("Reseed complete, " + total + " received");
    168                 System.clearProperty(PROP_ERROR);
     158                _checker.setError("");
    169159            } else if (total > 0) {
    170160                System.out.println("Reseed complete, only " + total + " received");
    171                 System.setProperty(PROP_ERROR, ngettext("Reseed fetched only 1 router.",
     161                _checker.setError(ngettext("Reseed fetched only 1 router.",
    172162                                                        "Reseed fetched only {0} routers.", total));
    173163            } else {
     
    176166                     "Ensure that nothing blocks outbound HTTP, check the logs, " +
    177167                     "and if nothing helps, read the FAQ about reseeding manually.");
    178                 System.setProperty(PROP_ERROR, _("Reseed failed.") + ' '  +
     168                _checker.setError(_("Reseed failed.") + ' '  +
    179169                                               _("See {0} for help.",
    180170                                                 "<a target=\"_top\" href=\"/configreseed\">" + _("reseed configuration page") + "</a>"));
    181171            }   
    182             System.setProperty(PROP_INPROGRESS, "false");
    183             System.clearProperty(PROP_STATUS);
    184             _sslState = null;  // don't hold ref
    185172            _isRunning = false;
     173            _checker.setStatus("");
    186174        }
    187175
     
    312300         * HREF="/full/path/to/routerInfo-...
    313301         *
    314          * We update PROP_STATUS here.
     302         * We update the status here.
    315303         *
    316304         * @param echoStatus apparently always false
     
    321309                // Don't use context clock as we may be adjusting the time
    322310                final long timeLimit = System.currentTimeMillis() + MAX_TIME_PER_HOST;
    323                 System.setProperty(PROP_STATUS, _("Reseeding: fetching seed URL."));
     311                _checker.setStatus(_("Reseeding: fetching seed URL."));
    324312                System.err.println("Reseeding from " + seedURL);
    325313                URL dir = new URL(seedURL);
     
    378366                     iter.hasNext() && fetched < 200 && System.currentTimeMillis() < timeLimit; ) {
    379367                    try {
    380                         System.setProperty(PROP_STATUS,
     368                        _checker.setStatus(
    381369                            _("Reseeding: fetching router info from seed URL ({0} successful, {1} errors).", fetched, errors));
    382370
Note: See TracChangeset for help on using the changeset viewer.