diff --git a/apps/routerconsole/java/build.xml b/apps/routerconsole/java/build.xml index 185c4976a5..8b97cc0f0f 100644 --- a/apps/routerconsole/java/build.xml +++ b/apps/routerconsole/java/build.xml @@ -330,6 +330,118 @@ splitindex="true" windowtitle="Router Console" /> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SlowTests + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java b/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java new file mode 100644 index 0000000000..54e54c6fab --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/ConsoleUpdateManager.java @@ -0,0 +1,1056 @@ +package net.i2p.router.update; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.net.URI; +import java.net.URISyntaxException; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.StringTokenizer; +import java.util.concurrent.ConcurrentHashMap; + +import net.i2p.I2PAppContext; +import net.i2p.crypto.TrustedUpdate; +import net.i2p.data.DataHelper; +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.RouterVersion; +import net.i2p.router.util.RFC822Date; +import net.i2p.router.web.ConfigServiceHandler; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.Messages; +import net.i2p.router.web.NewsHelper; +import net.i2p.router.web.PluginStarter; +import net.i2p.update.*; +import static net.i2p.update.UpdateType.*; +import static net.i2p.update.UpdateMethod.*; +import net.i2p.util.ConcurrentHashSet; +import net.i2p.util.FileUtil; +import net.i2p.util.Log; +import net.i2p.util.SimpleScheduler; +import net.i2p.util.SimpleTimer; +import net.i2p.util.VersionComparator; + +/** + * The central resource coordinating updates. + * This must be registered with the context. + * + * The UpdateManager starts and stops all updates, + * prevents multiple updates as appropriate, + * and controls notification to the user. + * + * @since 0.9.2 + */ +public class ConsoleUpdateManager implements UpdateManager { + + private final RouterContext _context; + private final Log _log; + /** registered checkers / updaters */ + private final Collection _registered; + /** active checking tasks */ + private final Collection _checkers; + /** active updating tasks, pointing to the next ones to try */ + private final Map> _downloaders; + /** as reported by checkers */ + private final Map _available; + /** downloaded but NOT installed */ + private final Map _downloaded; + /** downloaded but NOT installed */ + private final Map _installed; + private final DecimalFormat _pct = new DecimalFormat("0.0%"); + private static final VersionComparator _versionComparator = new VersionComparator(); + + private volatile String _status; + + public ConsoleUpdateManager(RouterContext ctx) { + _context = ctx; + _log = ctx.logManager().getLog(ConsoleUpdateManager.class); + _registered = new ConcurrentHashSet(); + _checkers = new ConcurrentHashSet(); + _downloaders = new ConcurrentHashMap(); + _available = new ConcurrentHashMap(); + _downloaded = new ConcurrentHashMap(); + _installed = new ConcurrentHashMap(); + _status = ""; + } + + public static ConsoleUpdateManager getInstance() { + return (ConsoleUpdateManager) I2PAppContext.getGlobalContext().updateManager(); + } + + public void start() { + notifyInstalled(NEWS, "", Long.toString(NewsHelper.lastUpdated(_context))); + notifyInstalled(ROUTER_SIGNED, "", RouterVersion.VERSION); + // hack to init from the current news file... do this before we register Updaters + (new NewsFetcher(_context, Collections.EMPTY_LIST)).checkForUpdates(); + for (String plugin : PluginStarter.getPlugins()) { + Properties props = PluginStarter.pluginProperties(_context, plugin); + String ver = props.getProperty("version"); + if (ver != null) + notifyInstalled(PLUGIN, plugin, ver); + } + + _context.registerUpdateManager(this); + Updater u = new DummyHandler(_context); + register(u, TYPE_DUMMY, HTTP, 0); + // register news before router, so we don't fire off an update + // right at instantiation if the news is already indicating a new version + u = new NewsHandler(_context); + register(u, NEWS, HTTP, 0); + register(u, ROUTER_SIGNED, HTTP, 0); // news is an update checker for the router + u = new UpdateHandler(_context); + register(u, ROUTER_SIGNED, HTTP, 0); + u = new UnsignedUpdateHandler(_context); + register(u, ROUTER_UNSIGNED, HTTP, 0); + u = new PluginUpdateHandler(_context); + register(u, PLUGIN, HTTP, 0); + register(u, PLUGIN_INSTALL, HTTP, 0); + new NewsTimerTask(_context); + } + + public void shutdown() { + _context.unregisterUpdateManager(this); + stopChecks(); + stopUpdates(); + _registered.clear(); + _available.clear(); + _downloaded.clear(); + _installed.clear(); + } + + /** + * The status on any update current or last finished. + * @return status or "" + */ + public String getStatus() { + return _status; + } + + public String checkAvailable(UpdateType type, long maxWait) { + return checkAvailable(type, "", maxWait); + } + + /** + * Is an update available? + * Blocking. + * @param maxWait max time to block + * @return new version or null if nothing newer is available + */ + public String checkAvailable(UpdateType type, String id, long maxWait) { +//// update too? + if (isCheckInProgress(type, id) || isUpdateInProgress(type, id)) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Check or update already in progress for: " + type + ' ' + id); + return null; + } + for (RegisteredUpdater r : _registered) { + if (r.type == type) { + UpdateTask t = r.updater.check(type, r.method, id, "FIXME", maxWait); + if (t != null) { + synchronized(t) { + try { + t.wait(maxWait); + } catch (InterruptedException ie) {} + } + return getUpdateAvailable(type, id); + } + } + } + return null; + } + + /** + * Fire off a checker task + * Non-blocking. + */ + public void check(UpdateType type, String id) { + if (isCheckInProgress(type, id)) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Check or update already in progress for: " + type + ' ' + id); + return; + } + for (RegisteredUpdater r : _registered) { + if (r.type == type) { +/// fixme "" will put an entry in _available for everything grrrrr???? + UpdateTask t = r.updater.check(type, r.method, id, "", 5*60*1000); + if (t != null) + break; + } + } + } + + /** + * Is an update available? + * Non-blocking, returns result of last check or notification from an Updater + * @return new version or null if nothing newer is available + */ + public String getUpdateAvailable(UpdateType type) { + return getUpdateAvailable(type, ""); + } + + /** + * Is an update available? + * Non-blocking, returns result of last check or notification from an Updater + * @return new version or null if nothing newer is available + */ + public String getUpdateAvailable(UpdateType type, String id) { + Version v = _available.get(new UpdateItem(type, id)); + if (v == null) + return null; + return v.version; + } + + /** + * Is an update downloaded? + * Non-blocking, returns result of last download + * @return new version or null if nothing was downloaded + */ + public String getUpdateDownloaded(UpdateType type) { + return getUpdateDownloaded(type, ""); + } + + /** + * Is an update downloaded? + * Non-blocking, returns result of last download + * @return new version or null if nothing was downloaded + */ + public String getUpdateDownloaded(UpdateType type, String id) { + Version v = _downloaded.get(new UpdateItem(type, id)); + if (v == null) + return null; + return v.version; + } + + /** + * Is any download in progress? + * Does not include checks. + */ + public boolean isUpdateInProgress() { + return !_downloaders.isEmpty(); + } + + /** + * Is a download in progress? + */ + public boolean isUpdateInProgress(UpdateType type) { + return isUpdateInProgress(type, ""); + } + + /** + * Is a download in progress? + */ + public boolean isUpdateInProgress(UpdateType type, String id) { + for (UpdateTask t : _downloaders.keySet()) { + if (t.getType() == type && id.equals(t.getID())) + return true; + } + return false; + } + + /** + * Stop all downloads in progress + */ + public void stopUpdates() { + for (UpdateTask t : _downloaders.keySet()) { + t.shutdown(); + } + _downloaders.clear(); + } + + /** + * Stop this download + */ + public void stopUpdate(UpdateType type) { + stopUpdate(type, ""); + } + + /** + * Stop this download + */ + public void stopUpdate(UpdateType type, String id) { + for (Iterator iter = _downloaders.keySet().iterator(); iter.hasNext(); ) { + UpdateTask t = iter.next(); + if (t.getType() == type && id.equals(t.getID())) { + iter.remove(); + t.shutdown(); + } + } + } + + /** + * Is any check in progress? + * Does not include updates. + */ + public boolean isCheckInProgress() { + return !_checkers.isEmpty(); + } + + /** + * Is a check in progress? + */ + public boolean isCheckInProgress(UpdateType type) { + return isCheckInProgress(type, ""); + } + + /** + * Is a check in progress? + */ + public boolean isCheckInProgress(UpdateType type, String id) { + for (UpdateTask t : _checkers) { + if (t.getType() == type && id.equals(t.getID())) + return true; + } + return false; + } + + /** + * Stop all checks in progress + */ + public void stopChecks() { + for (UpdateTask t : _checkers) { + t.shutdown(); + } + _checkers.clear(); + } + + /** + * Stop this check + */ + public void stopCheck(UpdateType type) { + stopCheck(type, ""); + } + + /** + * Stop this check + */ + public void stopCheck(UpdateType type, String id) { + for (Iterator iter = _checkers.iterator(); iter.hasNext(); ) { + UpdateTask t = iter.next(); + if (t.getType() == type && id.equals(t.getID())) { + iter.remove(); + t.shutdown(); + } + } + } + + /** + * Install a plugin. Non-blocking. + * If returns true, then call isUpdateInProgress() in a loop + * @return true if task started + */ + public boolean installPlugin(URI uri) { + String fakeName = Long.toString(_context.random().nextLong()); + List uris = Collections.singletonList(uri); + UpdateItem fake = new UpdateItem(PLUGIN_INSTALL, fakeName); + VersionAvailable va = new VersionAvailable("", "", HTTP, uris); + _available.put(fake, va); + return update(PLUGIN_INSTALL, fakeName); + } + + /** + * Non-blocking. Does not check. + * If returns true, then call isUpdateInProgress() in a loop + * Max time 3 hours by default but not honored by all Updaters + * @return true if task started + */ + public boolean update(UpdateType type) { + return update(type, "", 3*60*1000); + } + + /** + * Non-blocking. Does not check. + * Max time 3 hours by default but not honored by all Updaters + * If returns true, then call isUpdateInProgress() in a loop + * @return true if task started + */ + public boolean update(UpdateType type, String id) { + return update(type, id, 3*60*60*1000); + } + + /** + * Non-blocking. Does not check. + * If returns true, then call isUpdateInProgress() in a loop + * @param maxTime not honored by all Updaters + * @return true if task started + */ + public boolean update(UpdateType type, long maxTime) { + return update(type, "", maxTime); + } + + /** + * Non-blocking. Does not check. + * If returns true, then call isUpdateInProgress() in a loop + * @param maxTime not honored by all Updaters + * @return true if task started + */ + public boolean update(UpdateType type, String id, long maxTime) { + if (isCheckInProgress(type, id) || isUpdateInProgress(type, id)) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Check or update already in progress for: " + type + ' ' + id); + return false; + } + List updateSources = null; + UpdateItem ui = new UpdateItem(type, id); + VersionAvailable va = _available.get(ui); + if (va == null) + return false; + List sorted = new ArrayList(_registered); + Collections.sort(sorted); + return retry(ui, va.sourceMap, sorted, maxTime) != null; + } + + private UpdateTask retry(UpdateItem ui, + Map> sourceMap, + List toTry, long maxTime) { + for (Iterator iter = toTry.iterator(); iter.hasNext(); ) { + RegisteredUpdater r = iter.next(); + iter.remove(); + // check in case unregistered later + if (!_registered.contains(r)) + continue; + for (Map.Entry> e : sourceMap.entrySet()) { + UpdateMethod meth = e.getKey(); + if (r.type == ui.type && r.method == meth) { + // fixme + UpdateTask t = r.updater.update(ui.type, meth, e.getValue(), ui.id, "", maxTime); + if (t != null) { + // race window here + // store the remaining ones for retrying + _downloaders.put(t, toTry); + return t; + } + } + } + } + return null; + } + + /////////// start UpdateManager interface + + /** + * Call multiple times, one for each type/method pair. + */ + public void register(Updater updater, UpdateType type, UpdateMethod method, int priority) { + RegisteredUpdater ru = new RegisteredUpdater(updater, type, method, priority); + if (_log.shouldLog(Log.INFO)) + _log.info("Registering " + ru); + _registered.add(ru); + } + + public void unregister(Updater updater, UpdateType type, UpdateMethod method) { + RegisteredUpdater ru = new RegisteredUpdater(updater, type, method, 0); + if (_log.shouldLog(Log.INFO)) + _log.info("Unregistering " + ru); + _registered.remove(ru); + } + + /** + * Called by the Updater, either after check() was called, or it found out on its own. + * + * @param newsSource who told us + * @param id plugin name for plugins, ignored otherwise + * @param updateSourcew Where to get the new version + * @param newVersion The new version available + * @param minVersion The minimum installed version to be able to update to newVersion + * @return true if it's newer + */ + public boolean notifyVersionAvailable(UpdateTask task, URI newsSource, + UpdateType type, String id, + UpdateMethod method, List updateSources, + String newVersion, String minVersion) { + if (type == NEWS) { + // shortcut + notifyInstalled(NEWS, "", newVersion); + return true; + } + UpdateItem ui = new UpdateItem(type, id); + VersionAvailable newVA = new VersionAvailable(newVersion, minVersion, method, updateSources); + Version old = _installed.get(ui); + if (_log.shouldLog(Log.INFO)) + _log.info("notifyVersionAvailable " + ui + ' ' + newVA + " old: " + old); + if (old != null && old.compareTo(newVA) >= 0) { + if (_log.shouldLog(Log.WARN)) + _log.warn(ui.toString() + ' ' + old + " already installed"); + return false; + } + old = _downloaded.get(ui); + if (old != null && old.compareTo(newVA) >= 0) { + if (_log.shouldLog(Log.WARN)) + _log.warn(ui.toString() + ' ' + old + " already downloaded"); + return false; + } + VersionAvailable oldVA = _available.get(ui); + if (oldVA != null) { + int comp = oldVA.compareTo(newVA); + if (comp > 0) { + if (_log.shouldLog(Log.WARN)) + _log.warn(ui.toString() + ' ' + oldVA + " already available"); + return false; + } + if (comp == 0) { + if (oldVA.sourceMap.putIfAbsent(method, updateSources) == null) { + if (_log.shouldLog(Log.WARN)) + _log.warn(ui.toString() + ' ' + oldVA + " updated with new source method"); + } else { + if (_log.shouldLog(Log.WARN)) + _log.warn(ui.toString() + ' ' + oldVA + " already available"); + } + return false; + } + } + + if (_log.shouldLog(Log.INFO)) + _log.info(ui.toString() + ' ' + newVA + " now available"); + _available.put(ui, newVA); + + switch (type) { + case NEWS: + break; + + case ROUTER_SIGNED: + case ROUTER_SIGNED_PACK200: + if (shouldInstall()) { +//////////// + } + break; + + case ROUTER_UNSIGNED: + if (shouldInstall()) { +//////////// + } + break; + + case PLUGIN: + String msg = "" + _("New plugin version {0} is available", newVersion) + ""; + finishStatus(msg); + break; + + default: + break; + } + return true; +// TODO + } + + /** + * Called by the Updater after check() was called and all notifyVersionAvailable() callbacks are finished + */ + public void notifyCheckComplete(UpdateTask task, boolean newer, boolean success) { + if (_log.shouldLog(Log.INFO)) + _log.info(task.toString() + " complete"); + _checkers.remove(task); + switch (task.getType()) { + case NEWS: + // NewsFetcher will notify and spin off update tasks + break; + + case ROUTER_SIGNED: + case ROUTER_SIGNED_PACK200: + break; + + case ROUTER_UNSIGNED: + // if _mgr.getUpdateDownloaded(ROUTER_SIGNED) != null; + break; + + case PLUGIN: + String msg = null; + if (!success) + msg = "" + _("Update check failed for plugin {0}", task.getID()) + ""; + else if (!newer) + msg = "" + _("No new version is available for plugin {0}", task.getID()) + ""; + /// else success.... message for that? + + if (msg != null) + finishStatus(msg); + break; + + default: + break; + } + synchronized(task) { + task.notifyAll(); + } +// TODO + } + + public void notifyProgress(UpdateTask task, String status, long downloaded, long totalSize) { + StringBuilder buf = new StringBuilder(64); + buf.append(status).append(' '); + double pct = ((double)downloaded) / ((double)totalSize); + synchronized (_pct) { + buf.append(_pct.format(pct)); + } + buf.append("
\n"); + buf.append(_("{0}B transferred", DataHelper.formatSize2(downloaded))); + updateStatus(buf.toString()); + } + + /** + * @param task may be null + */ + public void notifyProgress(UpdateTask task, String status) { + updateStatus(status); + } + + /** + * An expiring status + * @param task may be null + */ + public void notifyComplete(UpdateTask task, String status) { + finishStatus(status); + } + + /** + * Not necessarily the end if there are more URIs to try. + * @param t may be null + */ + public void notifyAttemptFailed(UpdateTask task, String reason, Throwable t) { + _log.warn("Attempt failed " + task + ": " + reason, t); + } + + /** + * The task has finished and failed. + * @param t may be null + */ + public void notifyTaskFailed(UpdateTask task, String reason, Throwable t) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Failed " + task + ": " + reason, t); + List toTry = _downloaders.get(task); + if (toTry != null) { + UpdateItem ui = new UpdateItem(task.getType(), task.getID()); + VersionAvailable va = _available.get(ui); + if (va != null) { + UpdateTask next = retry(ui, va.sourceMap, toTry, 3*60*1000); // fixme old maxtime lost + if (next != null) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Retrying with " + next); + } + } + } + _downloaders.remove(task); +///// for certain types only + finishStatus("" + _("Transfer failed from {0}", linkify(task.getURI().toString())) + ""); + } + + /** + * An update has been downloaded but not verified. + * The manager will verify it. + * Caller should delete the file upon return, unless it will share it with others, + * e.g. on a torrent. + * If the return value is false, caller must call notifyTaskFailed() or notifyComplete() + * again. + * + * @param actualVersion may be higher (or lower?) than the version requested + * @param file a valid format for the task's UpdateType + * @return true if valid, false if corrupt + */ + public boolean notifyComplete(UpdateTask task, String actualVersion, File file) { + if (_log.shouldLog(Log.INFO)) + _log.info(task.toString() + " complete"); + boolean rv = false; + switch (task.getType()) { + case TYPE_DUMMY: + case NEWS: + rv = true; + break; + + case ROUTER_SIGNED: + case ROUTER_SIGNED_PACK200: + rv = handleSudFile(task.getURI(), actualVersion, file); + if (rv) + notifyDownloaded(task.getType(), task.getID(), actualVersion); + break; + + case ROUTER_UNSIGNED: + rv = handleUnsignedFile(task.getURI(), actualVersion, file); +/////// FIXME RFC822 or long? + if (rv) + notifyDownloaded(task.getType(), task.getID(), actualVersion); + break; + + case PLUGIN: +/// FIXME probably handled in PluginUpdateRunner?????????? + rv = handlePluginFile(task.getURI(), actualVersion, file); + break; + + default: + break; + } + if (rv) + _downloaders.remove(task); + return rv; + } + + ///////// End UpdateManager interface + + /** + * Adds to installed, removes from downloaded and available + * @param version null to remove from installed + */ + private void notifyInstalled(UpdateType type, String id, String version) { + UpdateItem ui = new UpdateItem(type, id); + if (version == null) { + _installed.remove(ui); + if (_log.shouldLog(Log.INFO)) + _log.info(ui + " removed"); + return; + } + Version ver = new Version(version); + if (_log.shouldLog(Log.INFO)) + _log.info(ui + " " + ver + " installed"); + _installed.put(ui, ver); + Version old = _downloaded.get(ui); + if (old != null && old.compareTo(ver) <= 0) + _downloaded.remove(ui); + old = _available.get(ui); + if (old != null && old.compareTo(ver) <= 0) + _available.remove(ui); + } + + /** + * Adds to downloaded, removes from available + */ + private void notifyDownloaded(UpdateType type, String id, String version) { + UpdateItem ui = new UpdateItem(type, id); + Version ver = new Version(version); + if (_log.shouldLog(Log.INFO)) + _log.info(ui + " " + ver + " downloaded"); + _downloaded.put(ui, ver); + // one trumps the other + if (type == ROUTER_SIGNED) + _downloaded.remove(new UpdateItem(ROUTER_UNSIGNED, "")); + else if (type == ROUTER_UNSIGNED) + _downloaded.remove(new UpdateItem(ROUTER_SIGNED, "")); + Version old = _available.get(ui); + if (old != null && old.compareTo(ver) <= 0) + _available.remove(ui); + } + + /** from NewsFetcher */ + private boolean shouldInstall() { + String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); + if ("notify".equals(policy) || NewsHelper.dontInstall(_context)) + return false; +////////////////// + File zip = new File(_context.getRouterDir(), Router.UPDATE_FILE); + return !zip.exists(); + } + + /** + * Where to find various resources + * @return non-null may be empty + */ + public List getUpdateURLs(UpdateType type, String id, UpdateMethod method) { + VersionAvailable va = _available.get(new UpdateItem(type, id)); + if (va != null) { + List rv = va.sourceMap.get(method); + if (rv != null) + return rv; + } + + switch (type) { + case NEWS: + // handled in NewsHandler + break; + + case ROUTER_SIGNED: + case ROUTER_SIGNED_PACK200: + String URLs = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_URL, ConfigUpdateHandler.DEFAULT_UPDATE_URL); + StringTokenizer tok = new StringTokenizer(URLs, " ,\r\n"); + List rv = new ArrayList(); + while (tok.hasMoreTokens()) { + try { + rv.add(new URI(tok.nextToken().trim())); + } catch (URISyntaxException use) {} + } + Collections.shuffle(rv, _context.random()); + return rv; + + case ROUTER_UNSIGNED: + String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); + if (url != null) { + try { + return Collections.singletonList(new URI(url)); + } catch (URISyntaxException use) {} + } + break; + + case PLUGIN: + Properties props = PluginStarter.pluginProperties(_context, id); + String oldVersion = props.getProperty("version"); + String xpi2pURL = props.getProperty("updateURL"); + if (xpi2pURL != null) { + try { + return Collections.singletonList(new URI(xpi2pURL)); + } catch (URISyntaxException use) {} + } + break; + + default: + break; + } + return Collections.EMPTY_LIST; + } + + /** + * @return success + */ + private boolean handleSudFile(URI uri, String actualVersion, File f) { + String url = uri.toString(); + // Process the .sud/.su2 file + updateStatus("" + _("Update downloaded") + ""); + TrustedUpdate up = new TrustedUpdate(_context); + File to = new File(_context.getRouterDir(), Router.UPDATE_FILE); + String err = up.migrateVerified(RouterVersion.VERSION, f, to); +/////////// + // caller must delete now.. why? + //f.delete(); + if (err == null) { + String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); + // So unsigned update handler doesn't overwrite unless newer. +/// FIXME + //String lastmod = _get.getLastModified(); + String lastmod = null; + long modtime = 0; + if (lastmod != null) + modtime = RFC822Date.parse822Date(lastmod); + if (modtime <= 0) + modtime = _context.clock().now(); + _context.router().saveConfig(NewsHelper.PROP_LAST_UPDATE_TIME, "" + modtime); + + if ("install".equals(policy)) { + _log.log(Log.CRIT, "Update was VERIFIED, restarting to install it"); + updateStatus("" + _("Update verified") + "
" + _("Restarting")); + restart(); + } else { + _log.log(Log.CRIT, "Update was VERIFIED, will be installed at next restart"); + StringBuilder buf = new StringBuilder(64); + buf.append("").append(_("Update downloaded")).append("
"); + if (_context.hasWrapper()) + buf.append(_("Click Restart to install")); + else + buf.append(_("Click Shutdown and restart to install")); + if (up.newVersion() != null) + buf.append(' ').append(_("Version {0}", up.newVersion())); + buf.append(""); + updateStatus(buf.toString()); + } + } else { + _log.log(Log.CRIT, err + " from " + url); + updateStatus("" + err + ' ' + _("from {0}", linkify(url)) + " "); + } + return err == null; + } + + /** + * @return success + */ + private boolean handleUnsignedFile(URI uri, String lastmod, File updFile) { + if (FileUtil.verifyZip(updFile)) { + updateStatus("" + _("Update downloaded") + ""); + } else { + updFile.delete(); + String url = uri.toString(); + updateStatus("" + _("Unsigned update file from {0} is corrupt", url) + ""); + _log.log(Log.CRIT, "Corrupt zip file from " + url); + return false; + } + File to = new File(_context.getRouterDir(), Router.UPDATE_FILE); + boolean copied = FileUtil.copy(updFile, to, true, false); + if (copied) { + updFile.delete(); + String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); + long modtime = 0; + if (lastmod != null) + modtime = RFC822Date.parse822Date(lastmod); + if (modtime <= 0) + modtime = _context.clock().now(); + _context.router().saveConfig(NewsHelper.PROP_LAST_UPDATE_TIME, "" + modtime); + if ("install".equals(policy)) { + _log.log(Log.CRIT, "Update was downloaded, restarting to install it"); + updateStatus("" + _("Update downloaded") + "
" + _("Restarting")); + restart(); + } else { + _log.log(Log.CRIT, "Update was downloaded, will be installed at next restart"); + StringBuilder buf = new StringBuilder(64); + buf.append("").append(_("Update downloaded")).append("
"); + if (_context.hasWrapper()) + buf.append(_("Click Restart to install")); + else + buf.append(_("Click Shutdown and restart to install")); +/// OK? + buf.append(' ').append(_("Version {0}", lastmod)); + updateStatus(buf.toString()); + } + } else { + _log.log(Log.CRIT, "Failed copy to " + to); + updateStatus("" + _("Failed copy to {0}", to.getAbsolutePath()) + ""); + } + return copied; + } + + /** + * @return success + */ + private boolean handlePluginFile(URI uri, String actualVersion, File sudFile) { + //////////////// handled elsewhere? + return false; + } + + private void restart() { + if (_context.hasWrapper()) + ConfigServiceHandler.registerWrapperNotifier(_context, Router.EXIT_GRACEFUL_RESTART, false); + _context.router().shutdownGracefully(Router.EXIT_GRACEFUL_RESTART); + } + + static String linkify(String url) { + return "" + url + ""; + } + + /** translate a string */ + private String _(String s) { + return Messages.getString(s, _context); + } + + /** + * translate a string with a parameter + */ + private String _(String s, Object o) { + return Messages.getString(s, o, _context); + } + + private void updateStatus(String s) { + _status = s; + } + + private void finishStatus(String msg) { + updateStatus(msg); + _context.simpleScheduler().addEvent(new Cleaner(msg), 20*60*1000); + } + + private class Cleaner implements SimpleTimer.TimedEvent { + private final String _msg; + public Cleaner(String msg) { + _msg = msg; + } + public void timeReached() { + if (_msg.equals(getStatus())) + updateStatus(""); + } + } + + /** + * Equals on updater, type and method only + */ + private static class RegisteredUpdater implements Comparable { + public final Updater updater; + public final UpdateType type; + public final UpdateMethod method; + public final int priority; + + public RegisteredUpdater(Updater u, UpdateType t, UpdateMethod m, int priority) { + updater = u; type = t; method = m; this.priority = priority; + } + + /** reverse, highest priority first, ensure different ones are different */ + public int compareTo(RegisteredUpdater r) { + int p = r.priority - priority; + if (p != 0) + return p; + return hashCode() - r.hashCode(); + } + + @Override + public int hashCode() { + return updater.hashCode() ^ type.hashCode() ^ method.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof RegisteredUpdater)) + return false; + RegisteredUpdater r = (RegisteredUpdater) o; + return type == r.type && method == r.method && + updater.equals(r.updater); + } + + @Override + public String toString() { + return "RegisteredUpdater " + updater + " for " + type + ' ' + method + " @pri " + priority; + } + } + + /** + * Equals on type and ID only + */ + private static class UpdateItem { + public final UpdateType type; + public final String id; + + public UpdateItem(UpdateType t, String id) { + type = t; + this.id = id; + } + + @Override + public int hashCode() { + return type.hashCode() ^ id.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof UpdateItem)) + return false; + UpdateItem r = (UpdateItem) o; + return type == r.type && id.equals(r.id); + } + + @Override + public String toString() { + return "UpdateItem " + type + ' ' + id; + } + } + + private static class Version implements Comparable { + public final String version; + + public Version(String version) { + this.version = version; + } + + public int compareTo(Version r) { + return _versionComparator.compare(version, r.version); + } + + @Override + public String toString() { + return "Version " + version; + } + } + + private static class VersionAvailable extends Version { + public final String minVersion; + public final ConcurrentHashMap> sourceMap; + + /** + * Puts the method and sources in the map. The map may be added to later. + */ + public VersionAvailable(String version, String min, UpdateMethod method, List updateSources) { + super(version); + minVersion = min; + sourceMap = new ConcurrentHashMap(4); + sourceMap.put(method, updateSources); + } + + @Override + public String toString() { + return "VersionAvailable " + version + ' ' + sourceMap; + } + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/DummyHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/DummyHandler.java new file mode 100644 index 0000000000..04b820ec41 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/DummyHandler.java @@ -0,0 +1,68 @@ +package net.i2p.router.update; + +import java.net.URI; +import java.util.Collections; +import java.util.List; + +import net.i2p.router.RouterContext; +import net.i2p.update.*; + +/** + * Dummy to lock up the updates for a period of time + * + * @since 0.9.2 + */ +class DummyHandler implements Updater { + private final RouterContext _context; + + public DummyHandler(RouterContext ctx) { + _context = ctx; + } + + /** + * Spins off an UpdateTask that sleeps + */ + public UpdateTask check(UpdateType type, UpdateMethod method, + String id, String currentVersion, long maxTime) { + if (type != UpdateType.TYPE_DUMMY) + return null; + return new DummyRunner(_context, maxTime); + } + + /** + * Spins off an UpdateTask that sleeps + */ + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String id, String newVersion, long maxTime) { + if (type != UpdateType.TYPE_DUMMY) + return null; + return new DummyRunner(_context, maxTime); + } + + /** + * Use for both check and update + */ + private static class DummyRunner extends UpdateRunner { + private final long _delay; + + public DummyRunner(RouterContext ctx, long maxTime) { + super(ctx, Collections.EMPTY_LIST); + _delay = maxTime; + } + + @Override + public UpdateType getType() { return UpdateType.TYPE_DUMMY; } + + @Override + protected void update() { + try { + Thread.sleep(_delay); + } catch (InterruptedException ie) {} + UpdateManager mgr = _context.updateManager(); + if (mgr != null) { + mgr.notifyCheckComplete(this, false, false); + mgr.notifyTaskFailed(this, "dummy", null); + } + } + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/NewsFetcher.java b/apps/routerconsole/java/src/net/i2p/router/update/NewsFetcher.java new file mode 100644 index 0000000000..5d74a8a4b8 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/NewsFetcher.java @@ -0,0 +1,198 @@ +package net.i2p.router.update; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.data.DataHelper; +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.RouterVersion; +import net.i2p.router.util.RFC822Date; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.ConfigUpdateHelper; +import net.i2p.router.web.NewsHelper; +import net.i2p.update.*; +import static net.i2p.update.UpdateType.*; +import static net.i2p.update.UpdateMethod.*; +import net.i2p.util.EepGet; +import net.i2p.util.EepHead; +import net.i2p.util.FileUtil; +import net.i2p.util.Log; + +/** + * Task to fetch updates to the news.xml, and to keep + * track of whether that has an announcement for a new version. + * + * @since 0.9.2 moved from NewsFetcher and make an Updater + */ +class NewsFetcher extends UpdateRunner { + private String _lastModified; + private final File _newsFile; + private final File _tempFile; + + private static final String TEMP_NEWS_FILE = "news.xml.temp"; + + public NewsFetcher(RouterContext ctx, List uris) { + super(ctx, uris); + _newsFile = new File(ctx.getRouterDir(), NewsHelper.NEWS_FILE); + _tempFile = new File(ctx.getTempDir(), "tmp-" + ctx.random().nextLong() + TEMP_NEWS_FILE); + long lastMod = NewsHelper.lastChecked(ctx); + if (lastMod > 0) + _lastModified = RFC822Date.to822Date(lastMod); + } + + @Override + public UpdateType getType() { return NEWS; } + + private boolean dontInstall() { + return NewsHelper.dontInstall(_context); + } + + private boolean shouldInstall() { + String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); + if ("notify".equals(policy) || dontInstall()) + return false; + File zip = new File(_context.getRouterDir(), Router.UPDATE_FILE); + return !zip.exists(); + } + + @Override + public void update() { + fetchNews(); + } + + public void fetchNews() { + boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); + String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); + int proxyPort = ConfigUpdateHandler.proxyPort(_context); + + for (URI uri : _urls) { + _currentURI = uri; + String newsURL = uri.toString(); + + if (_tempFile.exists()) + _tempFile.delete(); + + try { + EepGet get; + if (shouldProxy) + get = new EepGet(_context, true, proxyHost, proxyPort, 0, _tempFile.getAbsolutePath(), newsURL, true, null, _lastModified); + else + get = new EepGet(_context, false, null, 0, 0, _tempFile.getAbsolutePath(), newsURL, true, null, _lastModified); + get.addStatusListener(this); + if (get.fetch()) { + String lastMod = get.getLastModified(); + if (lastMod != null) { + _lastModified = lastMod; + long lm = RFC822Date.parse822Date(lastMod); + if (lm > 0) + _context.router().saveConfig(NewsHelper.PROP_LAST_CHECKED, Long.toString(lm)); + } + return; + } + } catch (Throwable t) { + _log.error("Error fetching the news", t); + } + } + } + + private static final String VERSION_STRING = "version=\"" + RouterVersion.VERSION + "\""; + private static final String VERSION_PREFIX = "version=\""; + +///// move to UpdateManager? + + /** + * Parse the installed (not the temp) news file for the latest version. + * TODO: Real XML parsing, different update methods, + * URLs in the file, ... + */ + void checkForUpdates() { + FileInputStream in = null; + try { + in = new FileInputStream(_newsFile); + StringBuilder buf = new StringBuilder(128); + while (DataHelper.readLine(in, buf)) { + int index = buf.indexOf(VERSION_PREFIX); + if (index >= 0) { + int end = buf.indexOf("\"", index + VERSION_PREFIX.length()); + if (end > index) { + String ver = buf.substring(index+VERSION_PREFIX.length(), end); + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Found version: [" + ver + "]"); + if (TrustedUpdate.needsUpdate(RouterVersion.VERSION, ver)) { + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Our version is out of date, update!"); + _mgr.notifyVersionAvailable(this, _currentURI, + ROUTER_SIGNED, "", HTTP, + _mgr.getUpdateURLs(ROUTER_SIGNED, "", HTTP), + ver, ""); + } else { + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Our version is current"); + } + return; + } + } + if (buf.indexOf(VERSION_STRING) == -1) { + if (_log.shouldLog(Log.DEBUG)) + _log.debug("No match in " + buf.toString()); + } + buf.setLength(0); + } + } catch (IOException ioe) { + if (_log.shouldLog(Log.WARN)) + _log.warn("Error checking the news for an update", ioe); + return; + } finally { + if (in != null) try { in.close(); } catch (IOException ioe) {} + } + + if (_log.shouldLog(Log.WARN)) + _log.warn("No version found in news.xml file"); + } + + /** override to prevent status update */ + @Override + public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) {} + + /** + * Copies the file from temp dir to the news location, + * calls checkForUpdates() + */ + @Override + public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { + if (_log.shouldLog(Log.INFO)) + _log.info("News fetched from " + url + " with " + (alreadyTransferred+bytesTransferred)); + + long now = _context.clock().now(); + if (_tempFile.exists()) { + boolean copied = FileUtil.copy(_tempFile, _newsFile, true, false); + _tempFile.delete(); + if (copied) { + String newVer = Long.toString(now); + _context.router().saveConfig(NewsHelper.PROP_LAST_UPDATED, newVer); + _mgr.notifyVersionAvailable(this, _currentURI, NEWS, "", HTTP, + null, newVer, ""); + checkForUpdates(); + } else { + if (_log.shouldLog(Log.ERROR)) + _log.error("Failed to copy the news file!"); + } + } else { + if (_log.shouldLog(Log.WARN)) + _log.warn("Transfer complete, but no file? - probably 304 Not Modified"); + } + } + + /** override to prevent status update */ + @Override + public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) {} +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/NewsHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/NewsHandler.java new file mode 100644 index 0000000000..135c254334 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/NewsHandler.java @@ -0,0 +1,56 @@ +package net.i2p.router.update; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.List; + +import net.i2p.router.RouterContext; +import net.i2p.router.web.ConfigUpdateHelper; +import net.i2p.update.*; + +/** + * Task to periodically look for updates to the news.xml, and to keep + * track of whether that has an announcement for a new version. + * + * @since 0.9.2 moved from NewsFetcher + */ +class NewsHandler extends UpdateHandler { + + /** @since 0.7.14 not configurable */ + private static final String BACKUP_NEWS_URL = "http://www.i2p2.i2p/_static/news/news.xml"; + + public NewsHandler(RouterContext ctx) { + super(ctx); + } + + /** + * This will check for news or router updates (it does the same thing). + * Should not block. + * @param currentVersion ignored, stored locally + */ + public UpdateTask check(UpdateType type, UpdateMethod method, + String id, String currentVersion, long maxTime) { + if ((type != UpdateType.ROUTER_SIGNED && type != UpdateType.ROUTER_SIGNED_PACK200 && type != UpdateType.NEWS) || + method != UpdateMethod.HTTP) + return null; + List updateSources = new ArrayList(2); + try { + updateSources.add(new URI(ConfigUpdateHelper.getNewsURL(_context))); + } catch (URISyntaxException use) {} + try { + updateSources.add(new URI(BACKUP_NEWS_URL)); + } catch (URISyntaxException use) {} + UpdateRunner update = new NewsFetcher(_context, updateSources); + update.start(); + return update; + } + + /** + * Does nothing. check() also does update. + */ + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String id, String newVersion, long maxTime) { + return null; + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/NewsTimerTask.java b/apps/routerconsole/java/src/net/i2p/router/update/NewsTimerTask.java new file mode 100644 index 0000000000..1ad65b3fcb --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/NewsTimerTask.java @@ -0,0 +1,109 @@ +package net.i2p.router.update; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.data.DataHelper; +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.RouterVersion; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.ConfigUpdateHelper; +import net.i2p.router.web.NewsHelper; +import static net.i2p.update.UpdateType.*; +import net.i2p.util.EepGet; +import net.i2p.util.EepHead; +import net.i2p.util.FileUtil; +import net.i2p.util.Log; +import net.i2p.util.SimpleScheduler; +import net.i2p.util.SimpleTimer; + +/** + * Task to periodically look for updates to the news.xml, and to keep + * track of whether that has an announcement for a new version. + * Also looks for unsigned updates. + * + * Runs forever on instantiation, can't be stopped. + * + * @since 0.9.2 moved from NewsFetcher + */ +class NewsTimerTask implements SimpleTimer.TimedEvent { + private final RouterContext _context; + private final Log _log; + private final ConsoleUpdateManager _mgr; + + private static final long INITIAL_DELAY = 5*60*1000; + private static final long RUN_DELAY = 10*60*1000; + + public NewsTimerTask(RouterContext ctx) { + _context = ctx; + _log = ctx.logManager().getLog(NewsTimerTask.class); + _mgr = (ConsoleUpdateManager) _context.updateManager(); + ctx.simpleScheduler().addPeriodicEvent(this, + INITIAL_DELAY + _context.random().nextLong(INITIAL_DELAY), + RUN_DELAY); + // UpdateManager calls NewsFetcher to check the existing news at startup + } + + public void timeReached() { + if (shouldFetchNews()) { + fetchNews(); + if (shouldFetchUnsigned()) + fetchUnsignedHead(); + } + } + + private boolean shouldFetchNews() { + if (_context.router().gracefulShutdownInProgress()) + return false; + if (NewsHelper.isUpdateInProgress()) + return false; + long lastFetch = NewsHelper.lastChecked(_context); + String freq = _context.getProperty(ConfigUpdateHandler.PROP_REFRESH_FREQUENCY, + ConfigUpdateHandler.DEFAULT_REFRESH_FREQUENCY); + try { + long ms = Long.parseLong(freq); + if (ms <= 0) + return false; + + if (lastFetch + ms < _context.clock().now()) { + return true; + } else { + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Last fetched " + DataHelper.formatDuration(_context.clock().now() - lastFetch) + " ago"); + return false; + } + } catch (NumberFormatException nfe) { + if (_log.shouldLog(Log.ERROR)) + _log.error("Invalid refresh frequency: " + freq); + return false; + } + } + + private void fetchNews() { + _mgr.check(NEWS, ""); + } + + private boolean shouldFetchUnsigned() { + String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); + return url != null && url.length() > 0 && + _context.getBooleanProperty(ConfigUpdateHandler.PROP_UPDATE_UNSIGNED) && + !NewsHelper.dontInstall(_context); + } + + /** + * HEAD the update url, and if the last-mod time is newer than the last update we + * downloaded, as stored in the properties, then we download it using eepget. + */ + private void fetchUnsignedHead() { + _mgr.check(ROUTER_UNSIGNED, ""); + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateChecker.java b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateChecker.java new file mode 100644 index 0000000000..3ae282f5b5 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateChecker.java @@ -0,0 +1,92 @@ +package net.i2p.router.update; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.net.URI; +import java.util.List; +import java.util.Properties; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.router.RouterContext; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.I2PAppThread; +import net.i2p.util.PartialEepGet; +import net.i2p.util.VersionComparator; + +/** + * Check for an updated version of a plugin. + * A plugin is a standard .sud file with a 40-byte signature, + * a 16-byte version, and a .zip file. + * + * So we get the current version and update URL for the installed plugin, + * then fetch the first 56 bytes of the URL, extract the version, + * and compare. + * + * Moved from web/ and turned into an UpdateTask. + * + * @since 0.7.12 + */ +class PluginUpdateChecker extends UpdateRunner { + private final ByteArrayOutputStream _baos; + private final String _appName; + private final String _oldVersion; + + public PluginUpdateChecker(RouterContext ctx, List uris, String appName, String oldVersion ) { + super(ctx, uris); + _baos = new ByteArrayOutputStream(TrustedUpdate.HEADER_BYTES); + if (!uris.isEmpty()) + _currentURI = uris.get(0); + _appName = appName; + _oldVersion = oldVersion; + } + + + @Override + public UpdateType getType() { return UpdateType.PLUGIN; } + + @Override + protected void update() { + // must be set for super + _isPartial = true; + updateStatus("" + _("Checking for update of plugin {0}", _appName) + ""); + // use the same settings as for updater + // always proxy, or else FIXME + //boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); + String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); + int proxyPort = ConfigUpdateHandler.proxyPort(_context); + _baos.reset(); + try { + _get = new PartialEepGet(_context, proxyHost, proxyPort, _baos, _currentURI.toString(), TrustedUpdate.HEADER_BYTES); + _get.addStatusListener(this); + _get.fetch(CONNECT_TIMEOUT); + } catch (Throwable t) { + _log.error("Error checking update for plugin", t); + } + } + + @Override + public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { + } + + @Override + public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { + // super sets _newVersion if newer + boolean newer = _newVersion != null; + if (newer) { + _mgr.notifyVersionAvailable(this, _currentURI, UpdateType.PLUGIN, _appName, UpdateMethod.HTTP, + _urls, _newVersion, _oldVersion); + } + _mgr.notifyCheckComplete(this, newer, true); + } + + @Override + public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) { + File f = new File(_updateFile); + f.delete(); + _mgr.notifyCheckComplete(this, false, false); + } +} + diff --git a/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateHandler.java new file mode 100644 index 0000000000..fe394135b3 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateHandler.java @@ -0,0 +1,92 @@ +package net.i2p.router.update; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Collections; +import java.util.List; +import java.util.Properties; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.router.RouterContext; +import net.i2p.router.web.PluginStarter; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.I2PAppThread; +import net.i2p.util.PartialEepGet; +import net.i2p.util.SimpleScheduler; +import net.i2p.util.SimpleTimer; +import net.i2p.util.VersionComparator; + +/** + * Check for or download an updated version of a plugin. + * A plugin is a standard .sud file with a 40-byte signature, + * a 16-byte version, and a .zip file. + * + * So we get the current version and update URL for the installed plugin, + * then fetch the first 56 bytes of the URL, extract the version, + * and compare. + * + * Moved from web/ and turned into an Updater. + * + * @since 0.7.12 + * @author zzz + */ +class PluginUpdateHandler implements Updater { + private final RouterContext _context; + + public PluginUpdateHandler(RouterContext ctx) { + _context = ctx; + } + + /** check a single plugin */ + @Override + public UpdateTask check(UpdateType type, UpdateMethod method, + String appName, String currentVersion, long maxTime) { + if ((type != UpdateType.PLUGIN) || + method != UpdateMethod.HTTP || appName.length() <= 0) + return null; + + Properties props = PluginStarter.pluginProperties(_context, appName); + String oldVersion = props.getProperty("version"); + String xpi2pURL = props.getProperty("updateURL"); + List updateSources = null; + if (xpi2pURL != null) { + try { + updateSources = Collections.singletonList(new URI(xpi2pURL)); + } catch (URISyntaxException use) {} + } + + if (oldVersion == null || updateSources == null) { + //updateStatus("" + _("Cannot check, plugin {0} is not installed", appName) + ""); + return null; + } + + UpdateRunner update = new PluginUpdateChecker(_context, updateSources, appName, oldVersion); + update.start(); + return update; + } + + /** download a single plugin */ + @Override + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String appName, String newVersion, long maxTime) { + if ((type != UpdateType.PLUGIN && type != UpdateType.PLUGIN_INSTALL) || + method != UpdateMethod.HTTP || updateSources.isEmpty()) + return null; + Properties props = PluginStarter.pluginProperties(_context, appName); + String oldVersion = props.getProperty("version"); + String xpi2pURL = props.getProperty("updateURL"); + if (oldVersion == null || xpi2pURL == null) { + //updateStatus("" + _("Cannot check, plugin {0} is not installed", appName) + ""); + return null; + } + + UpdateRunner update = new PluginUpdateRunner(_context, updateSources, appName, oldVersion); + update.start(); + return update; + } +} + diff --git a/apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java similarity index 80% rename from apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateHandler.java rename to apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java index 8e89570240..d75a8ef43d 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateHandler.java +++ b/apps/routerconsole/java/src/net/i2p/router/update/PluginUpdateRunner.java @@ -1,7 +1,9 @@ -package net.i2p.router.web; +package net.i2p.router.update; import java.io.File; import java.io.IOException; +import java.net.URI; +import java.util.List; import java.util.Map; import java.util.Properties; @@ -9,6 +11,12 @@ import net.i2p.CoreVersion; import net.i2p.crypto.TrustedUpdate; import net.i2p.data.DataHelper; import net.i2p.router.RouterContext; +import net.i2p.router.web.ConfigClientsHelper; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.LogsHelper; +import net.i2p.router.web.Messages; +import net.i2p.router.web.PluginStarter; +import net.i2p.update.*; import net.i2p.util.EepGet; import net.i2p.util.FileUtil; import net.i2p.util.I2PAppThread; @@ -19,107 +27,55 @@ import net.i2p.util.SimpleScheduler; import net.i2p.util.SimpleTimer; import net.i2p.util.VersionComparator; + /** - * Download and install a plugin. + * Check for an updated version of a plugin. * A plugin is a standard .sud file with a 40-byte signature, * a 16-byte version, and a .zip file. - * Unlike for router updates, we need not have the public key - * for the signature in advance. * - * The zip file must have a standard directory layout, with - * a plugin.config file at the top level. - * The config file contains properties for the package name, version, - * signing public key, and other settings. - * The zip file will typically contain a webapps/ or lib/ dir, - * and a webapps.config and/or clients.config file. + * So we get the current version and update URL for the installed plugin, + * then fetch the first 56 bytes of the URL, extract the version, + * and compare. * - * @since 0.7.12 - * @author zzz + * Moved from web/ and turned into an UpdateTask. + * + * @since 0.9.2 moved from PluginUpdateHandler */ -public class PluginUpdateHandler extends UpdateHandler { - private static PluginUpdateRunner _pluginUpdateRunner; - private String _xpi2pURL; - private String _appStatus; - private volatile boolean _updated; +class PluginUpdateRunner extends UpdateRunner { + + private String _appName; + private final String _oldVersion; + private final URI _uri; + private final String _xpi2pURL; + private boolean _updated; private static final String XPI2P = "app.xpi2p"; private static final String ZIP = XPI2P + ".zip"; - public static final String PLUGIN_DIR = "plugins"; + public static final String PLUGIN_DIR = PluginStarter.PLUGIN_DIR; - private static PluginUpdateHandler _instance; - public static final synchronized PluginUpdateHandler getInstance(RouterContext ctx) { - if (_instance != null) - return _instance; - _instance = new PluginUpdateHandler(ctx); - return _instance; + public PluginUpdateRunner(RouterContext ctx, List uris, String appName, String oldVersion ) { + super(ctx, uris); + if (uris.isEmpty()) + _uri = null; + else + _uri = uris.get(0); + _xpi2pURL = _uri.toString(); + _appName = appName; + _oldVersion = oldVersion; } - private PluginUpdateHandler(RouterContext ctx) { - super(ctx); - _appStatus = ""; - } - public void update(String xpi2pURL) { - // don't block waiting for the other one to finish - if ("true".equals(System.getProperty(PROP_UPDATE_IN_PROGRESS))) { - _log.error("Update already running"); - return; - } - synchronized (UpdateHandler.class) { - if (_pluginUpdateRunner == null) - _pluginUpdateRunner = new PluginUpdateRunner(_xpi2pURL); - if (_pluginUpdateRunner.isRunning()) - return; - _xpi2pURL = xpi2pURL; - _updateFile = (new File(_context.getTempDir(), "tmp" + _context.random().nextInt() + XPI2P)).getAbsolutePath(); - System.setProperty(PROP_UPDATE_IN_PROGRESS, "true"); - I2PAppThread update = new I2PAppThread(_pluginUpdateRunner, "AppDownload"); - update.start(); - } - } - - public String getAppStatus() { - return _appStatus; - } - - public boolean isRunning() { - return _pluginUpdateRunner != null && _pluginUpdateRunner.isRunning(); + @Override + public UpdateType getType() { + return _oldVersion.equals("") ? UpdateType.PLUGIN_INSTALL : UpdateType.PLUGIN; } @Override - public boolean isDone() { - // FIXME - return false; - } - - /** @since 0.8.13 */ - public boolean wasUpdateSuccessful() { - return _updated; - } - - private void scheduleStatusClean(String msg) { - _context.simpleScheduler().addEvent(new Cleaner(msg), 20*60*1000); - } - - private class Cleaner implements SimpleTimer.TimedEvent { - private final String _msg; - public Cleaner(String msg) { - _msg = msg; - } - public void timeReached() { - if (_msg.equals(getStatus())) - updateStatus(""); - } - } - - public class PluginUpdateRunner extends UpdateRunner implements Runnable, EepGet.StatusListener { - - public PluginUpdateRunner(String url) { - super(); - } + public URI getURI() { return _uri; } @Override protected void update() { + _updated = false; if(_xpi2pURL.startsWith("file://")) { updateStatus("" + _("Attempting to install from file {0}", _xpi2pURL) + ""); @@ -139,7 +95,7 @@ public class PluginUpdateHandler extends UpdateHandler { } else { updateStatus("" + _("Downloading plugin from {0}", _xpi2pURL) + ""); // use the same settings as for updater - boolean shouldProxy = Boolean.parseBoolean(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)); + boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); int proxyPort = ConfigUpdateHandler.proxyPort(_context); try { @@ -156,21 +112,6 @@ public class PluginUpdateHandler extends UpdateHandler { } } - @Override - public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { - StringBuilder buf = new StringBuilder(64); - buf.append("").append(_("Downloading plugin")).append(' '); - double pct = ((double)alreadyTransferred + (double)currentWrite) / - ((double)alreadyTransferred + (double)currentWrite + bytesRemaining); - synchronized (_pct) { - buf.append(_pct.format(pct)); - } - buf.append(": "); - buf.append(_("{0}B transferred", DataHelper.formatSize2(currentWrite + alreadyTransferred))); - buf.append(""); - updateStatus(buf.toString()); - } - @Override public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { boolean update = false; @@ -313,7 +254,7 @@ public class PluginUpdateHandler extends UpdateHandler { boolean wasRunning = false; File destDir = new SecureDirectory(appDir, appName); if (destDir.exists()) { - if (Boolean.parseBoolean(props.getProperty("install-only"))) { + if (Boolean.valueOf(props.getProperty("install-only")).booleanValue()) { to.delete(); statusDone("" + _("Downloaded plugin is for new installs only, but the plugin is already installed", url) + ""); return; @@ -374,7 +315,7 @@ public class PluginUpdateHandler extends UpdateHandler { return; } // do we defer extraction and installation? - if (Boolean.parseBoolean(props.getProperty("router-restart-required"))) { + if (Boolean.valueOf(props.getProperty("router-restart-required")).booleanValue()) { // Yup! try { if(!FileUtil.copy(to, (new SecureFile( new SecureFile(appDir.getCanonicalPath() +"/" + appName +"/"+ ZIP).getCanonicalPath())) , true, true)) { @@ -405,7 +346,7 @@ public class PluginUpdateHandler extends UpdateHandler { } update = true; } else { - if (Boolean.parseBoolean(props.getProperty("update-only"))) { + if (Boolean.valueOf(props.getProperty("update-only")).booleanValue()) { to.delete(); statusDone("" + _("Plugin is for upgrades only, but the plugin is not installed") + ""); return; @@ -426,7 +367,7 @@ public class PluginUpdateHandler extends UpdateHandler { _updated = true; to.delete(); // install != update. Changing the user's settings like this is probabbly a bad idea. - if (Boolean.parseBoolean( props.getProperty("dont-start-at-install"))) { + if (Boolean.valueOf( props.getProperty("dont-start-at-install")).booleanValue()) { statusDone("" + _("Plugin {0} installed", appName) + ""); if(!update) { Properties pluginProps = PluginStarter.pluginProperties(); @@ -468,15 +409,7 @@ public class PluginUpdateHandler extends UpdateHandler { private void statusDone(String msg) { updateStatus(msg); - scheduleStatusClean(msg); } - } - - @Override - protected void updateStatus(String s) { - super.updateStatus(s); - _appStatus = s; - } } diff --git a/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateChecker.java b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateChecker.java new file mode 100644 index 0000000000..f56979e36c --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateChecker.java @@ -0,0 +1,94 @@ +package net.i2p.router.update; + +import java.io.File; +import java.net.URI; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Date; + +import net.i2p.router.RouterContext; +import net.i2p.router.util.RFC822Date; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.Messages; +import net.i2p.update.*; +import net.i2p.util.EepHead; +import net.i2p.util.I2PAppThread; +import net.i2p.util.Log; + +/** + * Does a simple EepHead to get the last-modified header. + * Moved from NewsFetcher and turned into an UpdateTask. + * + * Overrides UpdateRunner for convenience, does not use super's Eepget StatusListener + * + * @since 0.9.2 + */ +class UnsignedUpdateChecker extends UpdateRunner { + private final long _ms; + private boolean _unsignedUpdateAvailable; + + protected static final String SIGNED_UPDATE_FILE = "i2pupdate.sud"; + + public UnsignedUpdateChecker(RouterContext ctx, List uris, long lastUpdateTime) { + super(ctx, uris); + _ms = lastUpdateTime; + } + + //////// begin UpdateTask methods + + @Override + public UpdateType getType() { return UpdateType.ROUTER_UNSIGNED; } + + //////// end UpdateTask methods + + @Override + public void run() { + _isRunning = true; + boolean success = false; + try { + success = fetchUnsignedHead(); + } finally { + _isRunning = false; + } + _mgr.notifyCheckComplete(this, _unsignedUpdateAvailable, success); + } + + + /** + * HEAD the update url, and if the last-mod time is newer than the last update we + * downloaded, as stored in the properties, then we download it using eepget. + */ + private boolean fetchUnsignedHead() { + if (_urls.isEmpty()) + return false; + _currentURI = _urls.get(0); + String url = _currentURI.toString(); + // assume always proxied for now + //boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); + String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); + int proxyPort = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_PORT, ConfigUpdateHandler.DEFAULT_PROXY_PORT_INT); + + try { + EepHead get = new EepHead(_context, proxyHost, proxyPort, 0, url); + if (get.fetch()) { + String lastmod = get.getLastModified(); + if (lastmod != null) { + long modtime = RFC822Date.parse822Date(lastmod); + if (modtime <= 0) return false; + if (_ms <= 0) return false; + if (modtime > _ms) { + _unsignedUpdateAvailable = true; + // '07-Jul 21:09 UTC' with month name in the system locale + String unsignedUpdateVersion = (new SimpleDateFormat("dd-MMM HH:mm")).format(new Date(modtime)) + " UTC"; + _mgr.notifyVersionAvailable(this, _urls.get(0), getType(), "", getMethod(), _urls, + unsignedUpdateVersion, ""); + } + } + return true; + } + } catch (Throwable t) { + _log.error("Error fetching the unsigned update", t); + } + return false; + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateHandler.java new file mode 100644 index 0000000000..7e5628684a --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateHandler.java @@ -0,0 +1,99 @@ +package net.i2p.router.update; + +import java.io.File; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Collections; +import java.util.List; + +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.util.RFC822Date; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.NewsHelper; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.FileUtil; +import net.i2p.util.I2PAppThread; +import net.i2p.util.Log; + +/** + *

Handles the request to update the router by firing off an + * {@link net.i2p.util.EepGet} call to download the latest unsigned zip file + * and displaying the status to anyone who asks. + *

+ *

After the download completes the signed update file is copied to the + * router directory, and if configured the router is restarted to complete + * the update process. + *

+ */ +class UnsignedUpdateHandler implements Updater { + private final RouterContext _context; + + public UnsignedUpdateHandler(RouterContext ctx) { + _context = ctx; + } + + /** + * @param currentVersion ignored, we use time stored in a property + */ + @Override + public UpdateTask check(UpdateType type, UpdateMethod method, + String id, String currentVersion, long maxTime) { + if (type != UpdateType.ROUTER_UNSIGNED || method != UpdateMethod.HTTP) + return null; + + String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); + if (url == null) + return null; + + List updateSources; + try { + updateSources = Collections.singletonList(new URI(url)); + } catch (URISyntaxException use) { + return null; + } + + String lastUpdate = _context.getProperty(NewsHelper.PROP_LAST_UPDATE_TIME); + if (lastUpdate == null) { + // we don't know what version you have, so stamp it with the current time, + // and we'll look for something newer next time around. + _context.router().saveConfig(NewsHelper.PROP_LAST_UPDATE_TIME, + Long.toString(_context.clock().now())); + return null; + } + long ms = 0; + try { + ms = Long.parseLong(lastUpdate); + } catch (NumberFormatException nfe) {} + if (ms <= 0) { + // we don't know what version you have, so stamp it with the current time, + // and we'll look for something newer next time around. + _context.router().saveConfig(NewsHelper.PROP_LAST_UPDATE_TIME, + Long.toString(_context.clock().now())); + return null; + } + + UpdateRunner update = new UnsignedUpdateChecker(_context, updateSources, ms); + update.start(); + return update; + } + + /** + * Start a download and return a handle to the download task. + * Should not block. + * + * @param id plugin name or ignored + * @param maxTime how long you have + * @return active task or null if unable to download + */ + @Override + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String id, String newVersion, long maxTime) { + if (type != UpdateType.ROUTER_UNSIGNED || method != UpdateMethod.HTTP || updateSources.isEmpty()) + return null; + UpdateRunner update = new UnsignedUpdateRunner(_context, updateSources); + update.start(); + return update; + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateRunner.java b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateRunner.java new file mode 100644 index 0000000000..57495f6348 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/UnsignedUpdateRunner.java @@ -0,0 +1,69 @@ +package net.i2p.router.update; + +import java.io.File; +import java.net.URI; +import java.util.List; + +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.util.RFC822Date; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.FileUtil; +import net.i2p.util.I2PAppThread; +import net.i2p.util.Log; + + +/** + * Eepget the .zip file to the temp dir, then notify.r + * Moved from UnsignedUpdateHandler and turned into an UpdateTask. + * + * @since 0.9.2 + */ +class UnsignedUpdateRunner extends UpdateRunner { + + public UnsignedUpdateRunner(RouterContext ctx, List uris) { + super(ctx, uris); + if (!uris.isEmpty()) + _currentURI = uris.get(0); + } + + + @Override + public UpdateType getType() { return UpdateType.ROUTER_UNSIGNED; } + + + /** Get the file */ + @Override + protected void update() { + String zipURL = _currentURI.toString(); + updateStatus("" + _("Updating") + ""); + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Starting unsigned update URL: " + zipURL); + // always proxy for now + //boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); + String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); + int proxyPort = ConfigUpdateHandler.proxyPort(_context); + try { + // 40 retries!! + _get = new EepGet(_context, proxyHost, proxyPort, 40, _updateFile, zipURL, false); + _get.addStatusListener(UnsignedUpdateRunner.this); + _get.fetch(CONNECT_TIMEOUT, -1, INACTIVITY_TIMEOUT); + } catch (Throwable t) { + _log.error("Error updating", t); + } + } + + /** eepget listener callback Overrides */ + @Override + public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { + String lastmod = _get.getLastModified(); + File tmp = new File(_updateFile); +/////// FIXME RFC822 or long? + if (_mgr.notifyComplete(this, lastmod, tmp)) + this.done = true; + else + tmp.delete(); // corrupt + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/UpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/update/UpdateHandler.java new file mode 100644 index 0000000000..9c79dcb282 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/UpdateHandler.java @@ -0,0 +1,69 @@ +package net.i2p.router.update; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.net.URI; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.StringTokenizer; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.data.DataHelper; +import net.i2p.router.Router; +import net.i2p.router.RouterContext; +import net.i2p.router.RouterVersion; +import net.i2p.router.util.RFC822Date; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.I2PAppThread; +import net.i2p.util.Log; +import net.i2p.util.PartialEepGet; +import net.i2p.util.VersionComparator; + +/** + *

Handles the request to update the router by firing one or more + * {@link net.i2p.util.EepGet} calls to download the latest signed update file + * and displaying the status to anyone who asks. + *

+ *

After the download completes the signed update file is verified with + * {@link net.i2p.crypto.TrustedUpdate}, and if it's authentic the payload + * of the signed update file is unpacked and the router is restarted to complete + * the update process. + *

+ * + * This does not do any checking, that is handled by the NewsFetcher. + */ +class UpdateHandler implements Updater { + protected final RouterContext _context; + + public UpdateHandler(RouterContext ctx) { + _context = ctx; + } + + /** Can't check, the NewsHandler does that */ + public UpdateTask check(UpdateType type, UpdateMethod method, + String id, String currentVersion, long maxTime) { + return null; + } + + /** + * Start a download and return a handle to the download task. + * Should not block. + * + * @param id plugin name or ignored + * @param maxTime how long you have + * @return active task or null if unable to download + */ + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String id, String newVersion, long maxTime) { + if ((type != UpdateType.ROUTER_SIGNED && type != UpdateType.ROUTER_SIGNED_PACK200) || + method != UpdateMethod.HTTP || updateSources.isEmpty()) + return null; + UpdateRunner update = new UpdateRunner(_context, updateSources); + update.start(); + return update; + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/UpdateRunner.java b/apps/routerconsole/java/src/net/i2p/router/update/UpdateRunner.java new file mode 100644 index 0000000000..798b886cda --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/UpdateRunner.java @@ -0,0 +1,235 @@ +package net.i2p.router.update; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.net.URI; +import java.util.List; +import java.util.StringTokenizer; + +import net.i2p.crypto.TrustedUpdate; +import net.i2p.data.DataHelper; +import net.i2p.router.RouterContext; +import net.i2p.router.RouterVersion; +import net.i2p.router.web.ConfigUpdateHandler; +import net.i2p.router.web.Messages; +import net.i2p.update.*; +import net.i2p.util.EepGet; +import net.i2p.util.I2PAppThread; +import net.i2p.util.Log; +import net.i2p.util.PartialEepGet; +import net.i2p.util.VersionComparator; + +/** + * The downloader for router signed updates, + * and the base class for all the other Checkers and Runners. + * + * @since 0.9.2 moved from UpdateHandler + * + */ +class UpdateRunner extends I2PAppThread implements UpdateTask, EepGet.StatusListener { + protected final RouterContext _context; + protected final Log _log; + protected final ConsoleUpdateManager _mgr; + protected final List _urls; + protected final String _updateFile; + protected volatile boolean _isRunning; + protected boolean done; + protected EepGet _get; + /** tells the listeners what mode we are in - set to true in extending classes for checks */ + protected boolean _isPartial; + /** set by the listeners on completion */ + protected String _newVersion; + private ByteArrayOutputStream _baos; + protected URI _currentURI; + + private static final String SIGNED_UPDATE_FILE = "i2pupdate.sud"; + + protected static final long CONNECT_TIMEOUT = 55*1000; + protected static final long INACTIVITY_TIMEOUT = 5*60*1000; + protected static final long NOPROXY_INACTIVITY_TIMEOUT = 60*1000; + + public UpdateRunner(RouterContext ctx, List uris) { + super("Update Runner"); + setDaemon(true); + _context = ctx; + _log = ctx.logManager().getLog(getClass()); + _mgr = (ConsoleUpdateManager) ctx.updateManager(); + _urls = uris; + _updateFile = (new File(ctx.getTempDir(), "update" + ctx.random().nextInt() + ".tmp")).getAbsolutePath(); + } + + //////// begin UpdateTask methods + + public boolean isRunning() { return _isRunning; } + + public void shutdown() { + _isRunning = false; + interrupt(); + } + + public UpdateType getType() { return UpdateType.ROUTER_SIGNED; } + + public UpdateMethod getMethod() { return UpdateMethod.HTTP; } + + public URI getURI() { return _currentURI; } + + public String getID() { return ""; } + + //////// end UpdateTask methods + + @Override + public void run() { + _isRunning = true; + try { + update(); + } finally { + _isRunning = false; + } + } + + /** + * Loop through the entire list of update URLs. + * For each one, first get the version from the first 56 bytes and see if + * it is newer than what we are running now. + * If it is, get the whole thing. + */ + protected void update() { + // Do a PartialEepGet on the selected URL, check for version we expect, + // and loop if it isn't what we want. + // This will allows us to do a release without waiting for the last host to install the update. + // Alternative: In bytesTransferred(), Check the data in the output file after + // we've received at least 56 bytes. Need a cancel() method in EepGet ? + + boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); + String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); + int proxyPort = ConfigUpdateHandler.proxyPort(_context); + + if (_urls.isEmpty()) { + // not likely, don't bother translating + updateStatus("Update source list is empty, cannot download update"); + _log.log(Log.CRIT, "Update source list is empty - cannot download update"); + _mgr.notifyTaskFailed(this, "", null); + return; + } + + ByteArrayOutputStream baos = null; + if (shouldProxy) + baos = new ByteArrayOutputStream(TrustedUpdate.HEADER_BYTES); + for (URI uri : _urls) { + _currentURI = uri; + String updateURL = uri.toString(); + updateStatus("" + _("Updating from {0}", linkify(updateURL)) + ""); + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Selected update URL: " + updateURL); + + // Check the first 56 bytes for the version + if (shouldProxy) { + _isPartial = true; + baos.reset(); + try { + // no retries + _get = new PartialEepGet(_context, proxyHost, proxyPort, baos, updateURL, TrustedUpdate.HEADER_BYTES); + _get.addStatusListener(UpdateRunner.this); + _get.fetch(CONNECT_TIMEOUT); + } catch (Throwable t) { + } + _isPartial = false; + if (_newVersion == null) + continue; + } + + // Now get the whole thing + try { + if (shouldProxy) + // 40 retries!! + _get = new EepGet(_context, proxyHost, proxyPort, 40, _updateFile, updateURL, false); + else + _get = new EepGet(_context, 1, _updateFile, updateURL, false); + _get.addStatusListener(UpdateRunner.this); + _get.fetch(CONNECT_TIMEOUT, -1, shouldProxy ? INACTIVITY_TIMEOUT : NOPROXY_INACTIVITY_TIMEOUT); + } catch (Throwable t) { + _log.error("Error updating", t); + } + if (this.done) + break; + } + (new File(_updateFile)).delete(); + if (!this.done) + _mgr.notifyTaskFailed(this, "", null); + } + + // EepGet Listeners below. + // We use the same for both the partial and the full EepGet, + // with a couple of adjustments depending on which mode. + + public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) { + if (_log.shouldLog(Log.DEBUG)) + _log.debug("Attempt failed on " + url, cause); + // ignored + } + + /** subclasses should override */ + public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { + if (_isPartial) + return; + long d = currentWrite + bytesTransferred; + String status = "" + _("Updating") + ""; + _mgr.notifyProgress(this, status, d, d + bytesRemaining); + } + + /** subclasses should override */ + public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { + if (_isPartial) { + // Compare version with what we have now + String newVersion = TrustedUpdate.getVersionString(new ByteArrayInputStream(_baos.toByteArray())); + boolean newer = (new VersionComparator()).compare(newVersion, RouterVersion.VERSION) > 0; + if (newer) { + _newVersion = newVersion; + } else { + updateStatus("" + _("No new version found at {0}", linkify(url)) + ""); + if (_log.shouldLog(Log.WARN)) + _log.warn("Found old version \"" + newVersion + "\" at " + url); + } + return; + } + + File tmp = new File(_updateFile); + if (_mgr.notifyComplete(this, _newVersion, tmp)) + this.done = true; + else + tmp.delete(); // corrupt + } + + /** subclasses should override */ + public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) { + // don't display bytesTransferred as it is meaningless + _log.error("Update from " + url + " did not download completely (" + + bytesRemaining + " remaining after " + currentAttempt + " tries)"); + updateStatus("" + _("Transfer failed from {0}", linkify(url)) + ""); + } + + public void headerReceived(String url, int attemptNum, String key, String val) {} + + public void attempting(String url) {} + + protected void updateStatus(String s) { + _mgr.notifyProgress(this, s); + } + + protected static String linkify(String url) { + return ConsoleUpdateManager.linkify(url); + } + + /** translate a string */ + protected String _(String s) { + return Messages.getString(s, _context); + } + + /** + * translate a string with a parameter + */ + protected String _(String s, Object o) { + return Messages.getString(s, o, _context); + } +} diff --git a/apps/routerconsole/java/src/net/i2p/router/update/package.html b/apps/routerconsole/java/src/net/i2p/router/update/package.html new file mode 100644 index 0000000000..5b03299139 --- /dev/null +++ b/apps/routerconsole/java/src/net/i2p/router/update/package.html @@ -0,0 +1,7 @@ + + +

+Classes to implement the update process. +

+ + diff --git a/apps/routerconsole/java/src/net/i2p/router/web/CSSHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/CSSHelper.java index 15c2b2b2c2..785af69a3e 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/CSSHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/CSSHelper.java @@ -59,7 +59,7 @@ public class CSSHelper extends HelperBase { public void setNews(String val) { // Protected with nonce in css.jsi if (val != null) - NewsFetcher.getInstance(_context).showNews(val.equals("1")); + NewsHelper.showNews(_context, val.equals("1")); } /** diff --git a/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHandler.java b/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHandler.java index 6c37db8290..06f87e377f 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHandler.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHandler.java @@ -1,6 +1,8 @@ package net.i2p.router.web; import java.io.File; +import java.net.URI; +import java.net.URISyntaxException; import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -12,6 +14,8 @@ import java.util.Set; import net.i2p.router.client.ClientManagerFacadeImpl; import net.i2p.router.startup.ClientAppConfig; import net.i2p.router.startup.LoadClientAppsJob; +import net.i2p.router.update.ConsoleUpdateManager; +import static net.i2p.update.UpdateType.*; import org.mortbay.jetty.handler.ContextHandlerCollection; @@ -333,7 +337,7 @@ public class ConfigClientsHandler extends FormHandler { /** @since 0.8.13 */ private void updateAllPlugins() { - if ("true".equals(System.getProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS))) { + if (NewsHelper.isAnyUpdateInProgress()) { addFormError(_("Plugin or update download already in progress.")); return; } @@ -346,17 +350,26 @@ public class ConfigClientsHandler extends FormHandler { } private void installPlugin(String url) { - if ("true".equals(System.getProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS))) { + ConsoleUpdateManager mgr = (ConsoleUpdateManager) _context.updateManager(); + if (mgr == null) { + addFormError("Update manager not registered, cannot install"); + return; + } + if (mgr.isUpdateInProgress()) { addFormError(_("Plugin or update download already in progress.")); return; } - PluginUpdateHandler puh = PluginUpdateHandler.getInstance(_context); - if (puh.isRunning()) { - addFormError(_("Plugin or update download already in progress.")); + URI uri; + try { + uri = new URI(url); + } catch (URISyntaxException use) { + addFormError(_("Bad URL {0}", url)); return; } - puh.update(url); - addFormNotice(_("Downloading plugin from {0}", url)); + if (mgr.installPlugin(uri)) + addFormNotice(_("Downloading plugin from {0}", url)); + else + addFormError("Cannot install, check logs"); // So that update() will post a status to the summary bar before we reload try { Thread.sleep(1000); @@ -364,16 +377,12 @@ public class ConfigClientsHandler extends FormHandler { } private void checkPlugin(String app) { - if ("true".equals(System.getProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS))) { - addFormError(_("Plugin or update download already in progress.")); + ConsoleUpdateManager mgr = (ConsoleUpdateManager) _context.updateManager(); + if (mgr == null) { + addFormError("Update manager not registered, cannot check"); return; } - PluginUpdateChecker puc = PluginUpdateChecker.getInstance(_context); - if (puc.isRunning()) { - addFormError(_("Plugin or update download already in progress.")); - return; - } - puc.update(app); + mgr.check(PLUGIN, app); addFormNotice(_("Checking plugin {0} for updates", app)); // So that update() will post a status to the summary bar before we reload try { diff --git a/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHelper.java index c381657015..b4a1155ffc 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/ConfigClientsHelper.java @@ -293,7 +293,7 @@ public class ConfigClientsHelper extends HelperBase { * Like in DataHelper but doesn't convert null to "" * There's a lot worse things a plugin could do but... */ - static String stripHTML(Properties props, String key) { + public static String stripHTML(Properties props, String key) { String orig = props.getProperty(key); if (orig == null) return null; String t1 = orig.replace('<', ' '); diff --git a/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHandler.java index a3b30d337a..0340dde3e7 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHandler.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHandler.java @@ -6,6 +6,8 @@ import java.util.Map; import net.i2p.I2PAppContext; import net.i2p.crypto.TrustedUpdate; import net.i2p.data.DataHelper; +import net.i2p.router.update.ConsoleUpdateManager; +import static net.i2p.update.UpdateType.*; import net.i2p.util.FileUtil; import net.i2p.util.PortMapper; @@ -84,7 +86,7 @@ public class ConfigUpdateHandler extends FormHandler { * @return the configured value, else the registered HTTP proxy, else the default * @since 0.8.13 */ - static int proxyPort(I2PAppContext ctx) { + public static int proxyPort(I2PAppContext ctx) { return ctx.getProperty(PROP_PROXY_PORT, ctx.portMapper().getPort(PortMapper.SVC_HTTP_PROXY, DEFAULT_PROXY_PORT_INT)); } @@ -94,11 +96,16 @@ public class ConfigUpdateHandler extends FormHandler { if (_action == null) return; if (_action.equals(_("Check for updates"))) { - NewsFetcher fetcher = NewsFetcher.getInstance(_context); - fetcher.fetchNews(); - if (fetcher.shouldFetchUnsigned()) - fetcher.fetchUnsignedHead(); - if (fetcher.updateAvailable() || fetcher.unsignedUpdateAvailable()) { + ConsoleUpdateManager mgr = (ConsoleUpdateManager) _context.updateManager(); + if (mgr == null) { + addFormError("Update manager not registered, cannot check"); + return; + } + boolean a1 = mgr.checkAvailable(NEWS, 60*1000) != null; + boolean a2 = false; + if ((!a1) && _updateUnsigned && _zipURL != null && _zipURL.length() > 0) + a2 = mgr.checkAvailable(ROUTER_UNSIGNED, 60*1000) != null; + if (a1 || a2) { if ( (_updatePolicy == null) || (!_updatePolicy.equals("notify")) ) addFormNotice(_("Update available, attempting to download now")); else @@ -118,7 +125,8 @@ public class ConfigUpdateHandler extends FormHandler { String oldURL = ConfigUpdateHelper.getNewsURL(_context); if ( (oldURL == null) || (!_newsURL.equals(oldURL)) ) { changes.put(PROP_NEWS_URL, _newsURL); - NewsFetcher.getInstance(_context).invalidateNews(); + // this invalidates the news + changes.put(NewsHelper.PROP_LAST_CHECKED, "0"); addFormNotice(_("Updating news URL to {0}", _newsURL)); } } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHelper.java index 07fad31975..7fecfc85f5 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/ConfigUpdateHelper.java @@ -14,7 +14,7 @@ public class ConfigUpdateHelper extends HelperBase { @Override public void setContextId(String contextId) { super.setContextId(contextId); - _dontInstall = NewsFetcher.getInstance(_context).dontInstall(); + _dontInstall = NewsHelper.dontInstall(_context); } public boolean canInstall() { @@ -159,6 +159,6 @@ public class ConfigUpdateHelper extends HelperBase { } public String getNewsStatus() { - return NewsFetcher.getInstance(_context).status(); + return NewsHelper.status(_context); } } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/FileDumpHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/FileDumpHelper.java index 7bb1e99d05..41ffec627b 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/FileDumpHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/FileDumpHelper.java @@ -60,7 +60,7 @@ public class FileDumpHelper extends HelperBase { dumpDir(buf, dir, ".war"); // plugins - File pluginDir = new File(_context.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR); + File pluginDir = new File(_context.getConfigDir(), PluginStarter.PLUGIN_DIR); File[] files = pluginDir.listFiles(); if (files != null) { Arrays.sort(files); diff --git a/apps/routerconsole/java/src/net/i2p/router/web/LogsHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/LogsHelper.java index de9d427eea..c2878b383c 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/LogsHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/LogsHelper.java @@ -20,7 +20,7 @@ public class LogsHelper extends HelperBase { } /** @since 0.8.13 */ - static String jettyVersion() { + public static String jettyVersion() { return Server.getVersion(); } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/NewsFetcher.java b/apps/routerconsole/java/src/net/i2p/router/web/NewsFetcher.java deleted file mode 100644 index 84b5a75ee5..0000000000 --- a/apps/routerconsole/java/src/net/i2p/router/web/NewsFetcher.java +++ /dev/null @@ -1,416 +0,0 @@ -package net.i2p.router.web; - -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.text.SimpleDateFormat; -import java.util.Date; - -import net.i2p.crypto.TrustedUpdate; -import net.i2p.data.DataHelper; -import net.i2p.router.Router; -import net.i2p.router.RouterContext; -import net.i2p.router.RouterVersion; -import net.i2p.router.util.RFC822Date; -import net.i2p.util.EepGet; -import net.i2p.util.EepHead; -import net.i2p.util.FileUtil; -import net.i2p.util.Log; - -/** - * Task to periodically look for updates to the news.xml, and to keep - * track of whether that has an announcement for a new version. - */ -public class NewsFetcher implements Runnable, EepGet.StatusListener { - private final RouterContext _context; - private final Log _log; - private boolean _updateAvailable; - private boolean _unsignedUpdateAvailable; - private long _lastFetch; - private long _lastUpdated; - private String _updateVersion; - private String _unsignedUpdateVersion; - private String _lastModified; - private boolean _invalidated; - private final File _newsFile; - private final File _tempFile; - private static NewsFetcher _instance; - private volatile boolean _isRunning; - - //public static final synchronized NewsFetcher getInstance() { return _instance; } - public static final synchronized NewsFetcher getInstance(RouterContext ctx) { - if (_instance != null) - return _instance; - _instance = new NewsFetcher(ctx); - return _instance; - } - - private static final String NEWS_FILE = "docs/news.xml"; - private static final String TEMP_NEWS_FILE = "news.xml.temp"; - /** @since 0.7.14 not configurable */ - private static final String BACKUP_NEWS_URL = "http://www.i2p2.i2p/_static/news/news.xml"; - private static final String PROP_LAST_CHECKED = "router.newsLastChecked"; - /** @since 0.8.12 */ - private static final String PROP_LAST_HIDDEN = "routerconsole.newsLastHidden"; - - private NewsFetcher(RouterContext ctx) { - _context = ctx; - _log = ctx.logManager().getLog(NewsFetcher.class); - _instance = this; - try { - String last = ctx.getProperty(PROP_LAST_CHECKED); - if (last != null) - _lastFetch = Long.parseLong(last); - } catch (NumberFormatException nfe) {} - _newsFile = new File(_context.getRouterDir(), NEWS_FILE); - _tempFile = new File(_context.getTempDir(), TEMP_NEWS_FILE); - updateLastFetched(); - _updateVersion = ""; - _isRunning = true; - } - - /** @since 0.8.8 */ - void shutdown() { - _isRunning = false; - } - - private void updateLastFetched() { - if (_newsFile.exists()) { - if (_lastUpdated == 0) - _lastUpdated = _newsFile.lastModified(); - if (_lastFetch == 0) - _lastFetch = _lastUpdated; - if (_lastModified == null) - _lastModified = RFC822Date.to822Date(_lastFetch); - } else { - _lastUpdated = 0; - _lastFetch = 0; - _lastModified = null; - } - } - - public boolean updateAvailable() { return _updateAvailable; } - public String updateVersion() { return _updateVersion; } - public boolean unsignedUpdateAvailable() { return _unsignedUpdateAvailable; } - public String unsignedUpdateVersion() { return _unsignedUpdateVersion; } - - /** - * Is the news newer than the last time it was hidden? - * @since 0.8.12 - */ - public boolean shouldShowNews() { - if (_lastUpdated <= 0) - return true; - String h = _context.getProperty(PROP_LAST_HIDDEN); - if (h == null) - return true; - long last = 0; - try { - last = Long.parseLong(h); - } catch (NumberFormatException nfe) {} - return _lastUpdated > last; - } - - /** - * Save config with the timestamp of the current news to hide, or 0 to show - * @since 0.8.12 - */ - public void showNews(boolean yes) { - long stamp = yes ? 0 : _lastUpdated; - _context.router().saveConfig(PROP_LAST_HIDDEN, Long.toString(stamp)); - } - - /** - * @return HTML - */ - public String status() { - StringBuilder buf = new StringBuilder(128); - long now = _context.clock().now(); - buf.append(""); - if (_lastUpdated > 0) { - buf.append(Messages.getString("News last updated {0} ago.", - DataHelper.formatDuration2(now - _lastUpdated), - _context)) - .append('\n'); - } - if (_lastFetch > _lastUpdated) { - buf.append(Messages.getString("News last checked {0} ago.", - DataHelper.formatDuration2(now - _lastFetch), - _context)); - } - buf.append(""); - String consoleNonce = System.getProperty("router.consoleNonce"); - if (_lastUpdated > 0 && consoleNonce != null) { - if (shouldShowNews()) { - buf.append(" ") - .append(Messages.getString("Hide news", _context)); - } else { - buf.append(" ") - .append(Messages.getString("Show news", _context)); - } - buf.append(""); - } - return buf.toString(); - } - - private static final long INITIAL_DELAY = 5*60*1000; - private static final long RUN_DELAY = 10*60*1000; - - public void run() { - try { Thread.sleep(INITIAL_DELAY + _context.random().nextLong(INITIAL_DELAY)); } catch (InterruptedException ie) {} - while (_isRunning) { - if (!_updateAvailable) checkForUpdates(); - if (shouldFetchNews()) { - fetchNews(); - if (shouldFetchUnsigned()) - fetchUnsignedHead(); - } - try { Thread.sleep(RUN_DELAY); } catch (InterruptedException ie) {} - } - } - - boolean dontInstall() { - File test = new File(_context.getBaseDir(), "history.txt"); - boolean readonly = ((test.exists() && !test.canWrite()) || (!_context.getBaseDir().canWrite())); - boolean disabled = _context.getBooleanProperty(ConfigUpdateHandler.PROP_UPDATE_DISABLED); - return readonly || disabled; - } - - private boolean shouldInstall() { - String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); - if ("notify".equals(policy) || dontInstall()) - return false; - File zip = new File(_context.getRouterDir(), Router.UPDATE_FILE); - return !zip.exists(); - } - - private boolean shouldFetchNews() { - if (_invalidated) - return true; - updateLastFetched(); - String freq = _context.getProperty(ConfigUpdateHandler.PROP_REFRESH_FREQUENCY, - ConfigUpdateHandler.DEFAULT_REFRESH_FREQUENCY); - try { - long ms = Long.parseLong(freq); - if (ms <= 0) - return false; - - if (_lastFetch + ms < _context.clock().now()) { - return true; - } else { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Last fetched " + DataHelper.formatDuration(_context.clock().now() - _lastFetch) + " ago"); - return false; - } - } catch (NumberFormatException nfe) { - if (_log.shouldLog(Log.ERROR)) - _log.error("Invalid refresh frequency: " + freq); - return false; - } - } - - /** - * Call this when changing news URLs to force an update next time the timer fires. - * @since 0.8.7 - */ - void invalidateNews() { - _lastModified = null; - _invalidated = true; - } - - public void fetchNews() { - String newsURL = ConfigUpdateHelper.getNewsURL(_context); - boolean shouldProxy = Boolean.parseBoolean(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)); - String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); - int proxyPort = ConfigUpdateHandler.proxyPort(_context); - if (_tempFile.exists()) - _tempFile.delete(); - - try { - EepGet get = null; - if (shouldProxy) - get = new EepGet(_context, true, proxyHost, proxyPort, 0, _tempFile.getAbsolutePath(), newsURL, true, null, _lastModified); - else - get = new EepGet(_context, false, null, 0, 0, _tempFile.getAbsolutePath(), newsURL, true, null, _lastModified); - get.addStatusListener(this); - if (get.fetch()) { - _lastModified = get.getLastModified(); - _invalidated = false; - } else { - // backup news location - always proxied - _tempFile.delete(); - get = new EepGet(_context, true, proxyHost, proxyPort, 0, _tempFile.getAbsolutePath(), BACKUP_NEWS_URL, true, null, _lastModified); - get.addStatusListener(this); - if (get.fetch()) - _lastModified = get.getLastModified(); - } - } catch (Throwable t) { - _log.error("Error fetching the news", t); - } - } - - public boolean shouldFetchUnsigned() { - String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); - return url != null && url.length() > 0 && - _context.getBooleanProperty(ConfigUpdateHandler.PROP_UPDATE_UNSIGNED) && - !dontInstall(); - } - - /** - * HEAD the update url, and if the last-mod time is newer than the last update we - * downloaded, as stored in the properties, then we download it using eepget. - */ - public void fetchUnsignedHead() { - String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); - if (url == null || url.length() <= 0) - return; - // assume always proxied for now - //boolean shouldProxy = Boolean.parseBoolean(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)); - String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); - int proxyPort = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_PORT, ConfigUpdateHandler.DEFAULT_PROXY_PORT_INT); - - try { - EepHead get = new EepHead(_context, proxyHost, proxyPort, 0, url); - if (get.fetch()) { - String lastmod = get.getLastModified(); - if (lastmod != null) { - long modtime = RFC822Date.parse822Date(lastmod); - if (modtime <= 0) return; - String lastUpdate = _context.getProperty(UpdateHandler.PROP_LAST_UPDATE_TIME); - if (lastUpdate == null) { - // we don't know what version you have, so stamp it with the current time, - // and we'll look for something newer next time around. - _context.router().saveConfig(UpdateHandler.PROP_LAST_UPDATE_TIME, - Long.toString(_context.clock().now())); - return; - } - long ms = 0; - try { - ms = Long.parseLong(lastUpdate); - } catch (NumberFormatException nfe) {} - if (ms <= 0) return; - if (modtime > ms) { - _unsignedUpdateAvailable = true; - // '07-Jul 21:09 UTC' with month name in the system locale - _unsignedUpdateVersion = (new SimpleDateFormat("dd-MMM HH:mm")).format(new Date(modtime)) + " UTC"; - if (shouldInstall()) - fetchUnsigned(); - } - } - } - } catch (Throwable t) { - _log.error("Error fetching the unsigned update", t); - } - } - - public void fetchUnsigned() { - String url = _context.getProperty(ConfigUpdateHandler.PROP_ZIP_URL); - if (url == null || url.length() <= 0) - return; - UpdateHandler handler = new UnsignedUpdateHandler(_context, url, - _unsignedUpdateVersion); - handler.update(); - } - - private static final String VERSION_STRING = "version=\"" + RouterVersion.VERSION + "\""; - private static final String VERSION_PREFIX = "version=\""; - private void checkForUpdates() { - _updateAvailable = false; - if ( (!_newsFile.exists()) || (_newsFile.length() <= 0) ) return; - FileInputStream in = null; - try { - in = new FileInputStream(_newsFile); - StringBuilder buf = new StringBuilder(128); - while (DataHelper.readLine(in, buf)) { - int index = buf.indexOf(VERSION_PREFIX); - if (index == -1) { - // skip - } else { - int end = buf.indexOf("\"", index + VERSION_PREFIX.length()); - if (end > index) { - String ver = buf.substring(index+VERSION_PREFIX.length(), end); - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Found version: [" + ver + "]"); - if (TrustedUpdate.needsUpdate(RouterVersion.VERSION, ver)) { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Our version is out of date, update!"); - _updateVersion = ver; - break; - } else { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Our version is current"); - return; - } - } - } - if (buf.indexOf(VERSION_STRING) != -1) { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Our version found, no need to update: " + buf.toString()); - return; - } else { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("No match in " + buf.toString()); - } - buf.setLength(0); - } - } catch (IOException ioe) { - if (_log.shouldLog(Log.WARN)) - _log.warn("Error checking the news for an update", ioe); - return; - } finally { - if (in != null) try { in.close(); } catch (IOException ioe) {} - } - // could not find version="0.5.0.1", so there must be an update ;) - - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Our version was NOT found (" + RouterVersion.VERSION + "), update needed"); - _updateAvailable = !dontInstall(); - - if (shouldInstall()) { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Policy requests update, so we update"); - UpdateHandler handler = new UpdateHandler(_context); - handler.update(); - } else { - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Policy requests manual update, so we do nothing"); - } - } - - public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) { - // ignore - } - public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { - // ignore - } - public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { - if (_log.shouldLog(Log.INFO)) - _log.info("News fetched from " + url + " with " + (alreadyTransferred+bytesTransferred)); - - long now = _context.clock().now(); - if (_tempFile.exists()) { - boolean copied = FileUtil.copy(_tempFile, _newsFile, true, false); - if (copied) { - _lastUpdated = now; - _tempFile.delete(); - checkForUpdates(); - } else { - if (_log.shouldLog(Log.ERROR)) - _log.error("Failed to copy the news file!"); - } - } else { - if (_log.shouldLog(Log.WARN)) - _log.warn("Transfer complete, but no file? - probably 304 Not Modified"); - } - _lastFetch = now; - _context.router().saveConfig(PROP_LAST_CHECKED, Long.toString(now)); - } - - public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) { - if (_log.shouldLog(Log.WARN)) - _log.warn("Failed to fetch the news from " + url); - _tempFile.delete(); - } - public void headerReceived(String url, int attemptNum, String key, String val) {} - public void attempting(String url) {} -} diff --git a/apps/routerconsole/java/src/net/i2p/router/web/NewsHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/NewsHelper.java index d5d702e8ff..f8a45b215c 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/NewsHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/NewsHelper.java @@ -2,6 +2,11 @@ package net.i2p.router.web; import java.io.File; +import net.i2p.data.DataHelper; +import net.i2p.router.RouterContext; +import net.i2p.router.update.ConsoleUpdateManager; +import static net.i2p.update.UpdateType.*; + /** * If news file does not exist, use file from the initialNews directory * in $I2P @@ -10,6 +15,86 @@ import java.io.File; */ public class NewsHelper extends ContentHelper { + public static final String PROP_LAST_UPDATE_TIME = "router.updateLastDownloaded"; + /** @since 0.8.12 */ + private static final String PROP_LAST_HIDDEN = "routerconsole.newsLastHidden"; + /** @since 0.9.2 */ + public static final String PROP_LAST_CHECKED = "routerconsole.newsLastChecked"; + /** @since 0.9.2 */ + public static final String PROP_LAST_UPDATED = "routerconsole.newsLastUpdated"; + public static final String NEWS_FILE = "docs/news.xml"; + + /** + * If ANY update is in progress. + * @since 0.9.2 was stored in system properties + */ + public static boolean isAnyUpdateInProgress() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return false; + return mgr.isUpdateInProgress(); + } + + /** + * If a signed or unsigned router update is in progress. + * Does NOT cover plugins, news, etc. + * @since 0.9.2 was stored in system properties + */ + public static boolean isUpdateInProgress() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return false; + return mgr.isUpdateInProgress(ROUTER_SIGNED) || + mgr.isUpdateInProgress(ROUTER_UNSIGNED) || + mgr.isUpdateInProgress(TYPE_DUMMY); + } + + /** + * @since 0.9.2 moved from NewsFetcher + */ + public static boolean isUpdateAvailable() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return false; + return mgr.getUpdateAvailable(ROUTER_SIGNED) != null; + } + + /** + * @return null if none + * @since 0.9.2 moved from NewsFetcher + */ + public static String updateVersion() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return null; + return mgr.getUpdateAvailable(ROUTER_SIGNED); + } + + /** + * @since 0.9.2 moved from NewsFetcher + */ + public static boolean isUnsignedUpdateAvailable() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return false; + return mgr.getUpdateAvailable(ROUTER_UNSIGNED) != null; + } + + /** + * @return null if none + * @since 0.9.2 moved from NewsFetcher + */ + public static String unsignedUpdateVersion() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return null; + return mgr.getUpdateAvailable(ROUTER_UNSIGNED); + } + + /** + * @return "" if none + * @since 0.9.2 moved from UpdateHelper + */ + public static String getUpdateStatus() { + ConsoleUpdateManager mgr = ConsoleUpdateManager.getInstance(); + if (mgr == null) return ""; + return mgr.getStatus(); + } + @Override public String getContent() { File news = new File(_page); @@ -18,8 +103,131 @@ public class NewsHelper extends ContentHelper { return super.getContent(); } - /** @since 0.8.12 */ + /** + * Is the news newer than the last time it was hidden? + * @since 0.8.12 + */ public boolean shouldShowNews() { - return NewsFetcher.getInstance(_context).shouldShowNews(); + return shouldShowNews(_context); + } + + /** + * @since 0.9.2 + */ + public static boolean shouldShowNews(RouterContext ctx) { + long lastUpdated = lastUpdated(ctx); + if (lastUpdated <= 0) + return true; + String h = ctx.getProperty(PROP_LAST_HIDDEN); + if (h == null) + return true; + long last = 0; + try { + last = Long.parseLong(h); + } catch (NumberFormatException nfe) {} + return lastUpdated > last; + } + + /** + * Save config with the timestamp of the current news to hide, or 0 to show + * @since 0.8.12 + */ + public void showNews(boolean yes) { + showNews(_context, yes); + } + + /** + * Save config with the timestamp of the current news to hide, or 0 to show + * @since 0.9.2 + */ + public static void showNews(RouterContext ctx, boolean yes) { + long lastUpdated = 0; +/////// FIME from props, or from last mod time? + long stamp = yes ? 0 : lastUpdated; + ctx.router().saveConfig(PROP_LAST_HIDDEN, Long.toString(stamp)); + } + + /** + * @return HTML + * @since 0.9.2 moved from NewsFetcher + */ + public String status() { + return status(_context); + } + + /** + * @return HTML + * @since 0.9.2 moved from NewsFetcher + */ + public static String status(RouterContext ctx) { + StringBuilder buf = new StringBuilder(128); + long now = ctx.clock().now(); + buf.append(""); + long lastUpdated = lastUpdated(ctx); + long lastFetch = lastChecked(ctx); + if (lastUpdated > 0) { + buf.append(Messages.getString("News last updated {0} ago.", + DataHelper.formatDuration2(now - lastUpdated), + ctx)) + .append('\n'); + } + if (lastFetch > lastUpdated) { + buf.append(Messages.getString("News last checked {0} ago.", + DataHelper.formatDuration2(now - lastFetch), + ctx)); + } + buf.append(""); + String consoleNonce = System.getProperty("router.consoleNonce"); + if (lastUpdated > 0 && consoleNonce != null) { + if (shouldShowNews(ctx)) { + buf.append(" ") + .append(Messages.getString("Hide news", ctx)); + } else { + buf.append(" ") + .append(Messages.getString("Show news", ctx)); + } + buf.append(""); + } + return buf.toString(); + } + + /** + * @since 0.9.2 moved from NewsFetcher + */ + public static boolean dontInstall(RouterContext ctx) { + File test = new File(ctx.getBaseDir(), "history.txt"); + boolean readonly = ((test.exists() && !test.canWrite()) || (!ctx.getBaseDir().canWrite())); + boolean disabled = ctx.getBooleanProperty(ConfigUpdateHandler.PROP_UPDATE_DISABLED); + return readonly || disabled; + } + + /** + * @since 0.9.2 + */ + public static long lastChecked(RouterContext ctx) { + String lc = ctx.getProperty(PROP_LAST_CHECKED); + if (lc == null) { + try { + return Long.parseLong(lc); + } catch (NumberFormatException nfe) {} + } + return 0; + } + + /** + * When the news was last downloaded + * @since 0.9.2 + */ + public static long lastUpdated(RouterContext ctx) { + String lc = ctx.getProperty(PROP_LAST_UPDATED); + if (lc == null) { + try { + return Long.parseLong(lc); + } catch (NumberFormatException nfe) {} + } + File newsFile = new File(ctx.getRouterDir(), NEWS_FILE); + long rv = newsFile.lastModified(); + ctx.router().saveConfig(PROP_LAST_UPDATED, Long.toString(rv)); + return rv; } } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/PluginStarter.java b/apps/routerconsole/java/src/net/i2p/router/web/PluginStarter.java index 60e9dd8c3a..6d70a9dbf0 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/PluginStarter.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/PluginStarter.java @@ -25,6 +25,8 @@ import net.i2p.router.RouterContext; import net.i2p.router.RouterVersion; import net.i2p.router.startup.ClientAppConfig; import net.i2p.router.startup.LoadClientAppsJob; +import net.i2p.router.update.ConsoleUpdateManager; +import static net.i2p.update.UpdateType.*; import net.i2p.util.ConcurrentHashSet; import net.i2p.util.FileUtil; import net.i2p.util.I2PAppThread; @@ -45,8 +47,9 @@ import org.mortbay.jetty.handler.ContextHandlerCollection; */ public class PluginStarter implements Runnable { protected RouterContext _context; - static final String PREFIX = "plugin."; - static final String ENABLED = ".startOnLoad"; + public static final String PREFIX = "plugin."; + public static final String ENABLED = ".startOnLoad"; + public static final String PLUGIN_DIR = "plugins"; private static final String[] STANDARD_WEBAPPS = { "i2psnark", "i2ptunnel", "susidns", "susimail", "addressbook", "routerconsole" }; private static final String[] STANDARD_THEMES = { "images", "light", "dark", "classic", @@ -66,7 +69,7 @@ public class PluginStarter implements Runnable { public void run() { if (_context.getBooleanPropertyDefaultTrue("plugins.autoUpdate") && - (!Boolean.parseBoolean(System.getProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS))) && + (!NewsHelper.isUpdateInProgress()) && (!RouterVersion.VERSION.equals(_context.getProperty("router.previousVersion")))) updateAll(_context, true); startPlugins(_context); @@ -112,18 +115,24 @@ public class PluginStarter implements Runnable { } if (toUpdate.isEmpty()) return; - PluginUpdateChecker puc = PluginUpdateChecker.getInstance(ctx); - if (puc.isRunning()) + + ConsoleUpdateManager mgr = (ConsoleUpdateManager) ctx.updateManager(); + if (mgr == null) + return; + if (mgr.isUpdateInProgress()) return; if (delay) { // wait for proxy - System.setProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS, "true"); - puc.setAppStatus(Messages.getString("Checking for plugin updates", ctx)); - try { - Thread.sleep(3*60*1000); - } catch (InterruptedException ie) {} - System.setProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS, "false"); + mgr.update(TYPE_DUMMY, 3*60*1000); + mgr.notifyProgress(null, Messages.getString("Checking for plugin updates", ctx)); + int loop = 0; + do { + try { + Thread.sleep(5*1000); + } catch (InterruptedException ie) {} + if (loop++ > 40) break; + } while (mgr.isUpdateInProgress(TYPE_DUMMY)); } Log log = ctx.logManager().getLog(PluginStarter.class); @@ -132,34 +141,32 @@ public class PluginStarter implements Runnable { String appName = entry.getKey(); if (log.shouldLog(Log.WARN)) log.warn("Checking for update plugin: " + appName); - puc.update(appName); - do { - try { - Thread.sleep(5*1000); - } catch (InterruptedException ie) {} - } while (puc.isRunning()); - if (!puc.isNewerAvailable()) { + + // blocking + if (mgr.checkAvailable(PLUGIN, appName, 60*1000) == null) { if (log.shouldLog(Log.WARN)) log.warn("No update available for plugin: " + appName); continue; } - PluginUpdateHandler puh = PluginUpdateHandler.getInstance(ctx); - String url = entry.getValue(); + if (log.shouldLog(Log.WARN)) log.warn("Updating plugin: " + appName); - puh.update(url); + mgr.update(PLUGIN, appName, 30*60*1000); + int loop = 0; do { try { Thread.sleep(5*1000); } catch (InterruptedException ie) {} - } while (puh.isRunning()); - if (puh.wasUpdateSuccessful()) + if (loop++ > 40) break; + } while (mgr.isUpdateInProgress(PLUGIN, appName)); + + if (mgr.getUpdateAvailable(PLUGIN, appName) != null) updated++; } if (updated > 0) - puc.setDoneStatus(ngettext("1 plugin updated", "{0} plugins updated", updated, ctx)); + mgr.notifyComplete(null, ngettext("1 plugin updated", "{0} plugins updated", updated, ctx)); else - puc.setDoneStatus(Messages.getString("Plugin update check complete", ctx)); + mgr.notifyComplete(null, Messages.getString("Plugin update check complete", ctx)); } /** this shouldn't throw anything */ @@ -189,9 +196,9 @@ public class PluginStarter implements Runnable { * @return true on success * @throws just about anything, caller would be wise to catch Throwable */ - static boolean startPlugin(RouterContext ctx, String appName) throws Exception { + public static boolean startPlugin(RouterContext ctx, String appName) throws Exception { Log log = ctx.logManager().getLog(PluginStarter.class); - File pluginDir = new File(ctx.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR + '/' + appName); + File pluginDir = new File(ctx.getConfigDir(), PLUGIN_DIR + '/' + appName); if ((!pluginDir.exists()) || (!pluginDir.isDirectory())) { log.error("Cannot start nonexistent plugin: " + appName); disablePlugin(appName); @@ -199,7 +206,7 @@ public class PluginStarter implements Runnable { } // Do we need to extract an update? - File pluginUpdate = new File(ctx.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR + '/' + appName + "/app.xpi2p.zip" ); + File pluginUpdate = new File(ctx.getConfigDir(), PLUGIN_DIR + '/' + appName + "/app.xpi2p.zip" ); if(pluginUpdate.exists()) { // Compare the start time of the router with the plugin. if(ctx.router().getWhenStarted() > pluginUpdate.lastModified()) { @@ -363,9 +370,9 @@ public class PluginStarter implements Runnable { * @return true on success * @throws just about anything, caller would be wise to catch Throwable */ - static boolean stopPlugin(RouterContext ctx, String appName) throws Exception { + public static boolean stopPlugin(RouterContext ctx, String appName) throws Exception { Log log = ctx.logManager().getLog(PluginStarter.class); - File pluginDir = new File(ctx.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR + '/' + appName); + File pluginDir = new File(ctx.getConfigDir(), PLUGIN_DIR + '/' + appName); if ((!pluginDir.exists()) || (!pluginDir.isDirectory())) { log.error("Cannot stop nonexistent plugin: " + appName); return false; @@ -424,7 +431,7 @@ public class PluginStarter implements Runnable { /** @return true on success - caller should call stopPlugin() first */ static boolean deletePlugin(RouterContext ctx, String appName) throws Exception { Log log = ctx.logManager().getLog(PluginStarter.class); - File pluginDir = new File(ctx.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR + '/' + appName); + File pluginDir = new File(ctx.getConfigDir(), PLUGIN_DIR + '/' + appName); if ((!pluginDir.exists()) || (!pluginDir.isDirectory())) { log.error("Cannot delete nonexistent plugin: " + appName); return false; @@ -469,7 +476,7 @@ public class PluginStarter implements Runnable { /** plugin.config */ public static Properties pluginProperties(I2PAppContext ctx, String appName) { - File cfgFile = new File(ctx.getConfigDir(), PluginUpdateHandler.PLUGIN_DIR + '/' + appName + '/' + "plugin.config"); + File cfgFile = new File(ctx.getConfigDir(), PLUGIN_DIR + '/' + appName + '/' + "plugin.config"); Properties rv = new Properties(); try { DataHelper.loadProps(rv, cfgFile); @@ -530,7 +537,7 @@ public class PluginStarter implements Runnable { */ public static List getPlugins() { List rv = new ArrayList(); - File pluginDir = new File(I2PAppContext.getGlobalContext().getConfigDir(), PluginUpdateHandler.PLUGIN_DIR); + File pluginDir = new File(I2PAppContext.getGlobalContext().getConfigDir(), PLUGIN_DIR); File[] files = pluginDir.listFiles(); if (files == null) return rv; diff --git a/apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateChecker.java b/apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateChecker.java deleted file mode 100644 index 31dfb623f2..0000000000 --- a/apps/routerconsole/java/src/net/i2p/router/web/PluginUpdateChecker.java +++ /dev/null @@ -1,200 +0,0 @@ -package net.i2p.router.web; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.File; -import java.util.List; -import java.util.Properties; - -import net.i2p.crypto.TrustedUpdate; -import net.i2p.router.RouterContext; -import net.i2p.util.EepGet; -import net.i2p.util.I2PAppThread; -import net.i2p.util.PartialEepGet; -import net.i2p.util.SimpleScheduler; -import net.i2p.util.SimpleTimer; -import net.i2p.util.VersionComparator; - -/** - * Check for an updated version of a plugin. - * A plugin is a standard .sud file with a 40-byte signature, - * a 16-byte version, and a .zip file. - * - * So we get the current version and update URL for the installed plugin, - * then fetch the first 56 bytes of the URL, extract the version, - * and compare. - * - * @since 0.7.12 - * @author zzz - */ -public class PluginUpdateChecker extends UpdateHandler { - private static PluginUpdateCheckerRunner _pluginUpdateCheckerRunner; - private String _appName; - private String _oldVersion; - private String _xpi2pURL; - private volatile boolean _isNewerAvailable; - - private static PluginUpdateChecker _instance; - public static final synchronized PluginUpdateChecker getInstance(RouterContext ctx) { - if (_instance != null) - return _instance; - _instance = new PluginUpdateChecker(ctx); - return _instance; - } - - private PluginUpdateChecker(RouterContext ctx) { - super(ctx); - } - - /** - * check all plugins - * @deprecated not finished - */ - public void update() { - Thread t = new I2PAppThread(new AllCheckerRunner(), "AllAppChecker", true); - t.start(); - } - - /** - * check all plugins - * @deprecated not finished - */ - public class AllCheckerRunner implements Runnable { - public void run() { - List plugins = PluginStarter.getPlugins(); - // TODO - } - } - - /** check a single plugin */ - public void update(String appName) { - // don't block waiting for the other one to finish - if ("true".equals(System.getProperty(PROP_UPDATE_IN_PROGRESS))) { - _log.error("Update already running"); - return; - } - synchronized (UpdateHandler.class) { - Properties props = PluginStarter.pluginProperties(_context, appName); - String oldVersion = props.getProperty("version"); - String xpi2pURL = props.getProperty("updateURL"); - if (oldVersion == null || xpi2pURL == null) { - updateStatus("" + _("Cannot check, plugin {0} is not installed", appName) + ""); - return; - } - - if (_pluginUpdateCheckerRunner == null) - _pluginUpdateCheckerRunner = new PluginUpdateCheckerRunner(); - if (_pluginUpdateCheckerRunner.isRunning()) - return; - _xpi2pURL = xpi2pURL; - _appName = appName; - _oldVersion = oldVersion; - _isNewerAvailable = false; - System.setProperty(PROP_UPDATE_IN_PROGRESS, "true"); - I2PAppThread update = new I2PAppThread(_pluginUpdateCheckerRunner, "AppChecker", true); - update.start(); - } - } - - /** @since 0.8.13 */ - public void setAppStatus(String status) { - updateStatus(status); - } - - /** @since 0.8.13 */ - public void setDoneStatus(String status) { - updateStatus(status); - scheduleStatusClean(status); - } - - public boolean isRunning() { - return _pluginUpdateCheckerRunner != null && _pluginUpdateCheckerRunner.isRunning(); - } - - @Override - public boolean isDone() { - // FIXME - return false; - } - - /** @since 0.8.13 */ - public boolean isNewerAvailable() { - return _isNewerAvailable; - } - - private void scheduleStatusClean(String msg) { - _context.simpleScheduler().addEvent(new Cleaner(msg), 20*60*1000); - } - - private class Cleaner implements SimpleTimer.TimedEvent { - private final String _msg; - public Cleaner(String msg) { - _msg = msg; - } - public void timeReached() { - if (_msg.equals(getStatus())) - updateStatus(""); - } - } - - public class PluginUpdateCheckerRunner extends UpdateRunner implements Runnable, EepGet.StatusListener { - ByteArrayOutputStream _baos; - - public PluginUpdateCheckerRunner() { - super(); - _baos = new ByteArrayOutputStream(TrustedUpdate.HEADER_BYTES); - } - - @Override - protected void update() { - _isNewerAvailable = false; - updateStatus("" + _("Checking for update of plugin {0}", _appName) + ""); - // use the same settings as for updater - // always proxy, or else FIXME - //boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); - String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); - int proxyPort = ConfigUpdateHandler.proxyPort(_context); - _baos.reset(); - try { - _get = new PartialEepGet(_context, proxyHost, proxyPort, _baos, _xpi2pURL, TrustedUpdate.HEADER_BYTES); - _get.addStatusListener(PluginUpdateCheckerRunner.this); - _get.fetch(CONNECT_TIMEOUT); - } catch (Throwable t) { - _log.error("Error checking update for plugin", t); - } - } - - public boolean isNewerAvailable() { - return _isNewerAvailable; - } - - @Override - public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { - } - - @Override - public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { - String newVersion = TrustedUpdate.getVersionString(new ByteArrayInputStream(_baos.toByteArray())); - boolean newer = (new VersionComparator()).compare(newVersion, _oldVersion) > 0; - String msg; - if (newer) { - msg = "" + _("New plugin version {0} is available", newVersion) + ""; - _isNewerAvailable = true; - } else { - msg = "" + _("No new version is available for plugin {0}", _appName) + ""; - } - updateStatus(msg); - scheduleStatusClean(msg); - } - - @Override - public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) { - File f = new File(_updateFile); - f.delete(); - String msg = "" + _("Update check failed for plugin {0}", _appName) + ""; - updateStatus(msg); - scheduleStatusClean(msg); - } - } -} - diff --git a/apps/routerconsole/java/src/net/i2p/router/web/RouterConsoleRunner.java b/apps/routerconsole/java/src/net/i2p/router/web/RouterConsoleRunner.java index 488c5b655d..2144fc8c1d 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/RouterConsoleRunner.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/RouterConsoleRunner.java @@ -27,6 +27,7 @@ import net.i2p.apps.systray.SysTray; import net.i2p.data.Base32; import net.i2p.data.DataHelper; import net.i2p.router.RouterContext; +import net.i2p.router.update.ConsoleUpdateManager; import net.i2p.util.Addresses; import net.i2p.util.FileUtil; import net.i2p.util.I2PAppThread; @@ -568,10 +569,8 @@ public class RouterConsoleRunner { if (contexts != null) { RouterContext ctx = contexts.get(0); - NewsFetcher fetcher = NewsFetcher.getInstance(ctx); - Thread newsThread = new I2PAppThread(fetcher, "NewsFetcher", true); - newsThread.setPriority(Thread.NORM_PRIORITY - 1); - newsThread.start(); + ConsoleUpdateManager um = new ConsoleUpdateManager(ctx); + um.start(); if (PluginStarter.pluginsEnabled(ctx)) { t = new I2PAppThread(new PluginStarter(ctx), "PluginStarter", true); @@ -579,7 +578,6 @@ public class RouterConsoleRunner { t.start(); ctx.addShutdownTask(new PluginStopper(ctx)); } - ctx.addShutdownTask(new NewsShutdown(fetcher, newsThread)); // stat summarizer registers its own hook ctx.addShutdownTask(new ServerShutdown()); ConfigServiceHandler.registerSignalHandler(ctx); @@ -751,22 +749,6 @@ public class RouterConsoleRunner { } } - /** @since 0.8.8 */ - private static class NewsShutdown implements Runnable { - private final NewsFetcher _fetcher; - private final Thread _newsThread; - - public NewsShutdown(NewsFetcher fetcher, Thread t) { - _fetcher = fetcher; - _newsThread = t; - } - - public void run() { - _fetcher.shutdown(); - _newsThread.interrupt(); - } - } - public static Properties webAppProperties() { return webAppProperties(I2PAppContext.getGlobalContext().getConfigDir().getAbsolutePath()); } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/SummaryHelper.java b/apps/routerconsole/java/src/net/i2p/router/web/SummaryHelper.java index 99a64df949..abc52aa654 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/SummaryHelper.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/SummaryHelper.java @@ -628,19 +628,19 @@ public class SummaryHelper extends HelperBase { ********/ public boolean updateAvailable() { - return NewsFetcher.getInstance(_context).updateAvailable(); + return NewsHelper.isUpdateAvailable(); } public boolean unsignedUpdateAvailable() { - return NewsFetcher.getInstance(_context).unsignedUpdateAvailable(); + return NewsHelper.isUnsignedUpdateAvailable(); } public String getUpdateVersion() { - return NewsFetcher.getInstance(_context).updateVersion(); + return NewsHelper.updateVersion(); } public String getUnsignedUpdateVersion() { - return NewsFetcher.getInstance(_context).unsignedUpdateVersion(); + return NewsHelper.unsignedUpdateVersion(); } /** @@ -650,12 +650,12 @@ public class SummaryHelper extends HelperBase { public String getUpdateStatus() { StringBuilder buf = new StringBuilder(512); // display all the time so we display the final failure message, and plugin update messages too - String status = UpdateHandler.getStatus(); + String status = NewsHelper.getUpdateStatus(); if (status.length() > 0) { buf.append("

").append(status).append("

\n"); } if (updateAvailable() || unsignedUpdateAvailable()) { - if ("true".equals(System.getProperty(UpdateHandler.PROP_UPDATE_IN_PROGRESS))) { + if (NewsHelper.isUpdateInProgress()) { // nothing } else if( // isDone() is always false for now, see UpdateHandler diff --git a/apps/routerconsole/java/src/net/i2p/router/web/UnsignedUpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/web/UnsignedUpdateHandler.java deleted file mode 100644 index 4725f62b16..0000000000 --- a/apps/routerconsole/java/src/net/i2p/router/web/UnsignedUpdateHandler.java +++ /dev/null @@ -1,130 +0,0 @@ -package net.i2p.router.web; - -import java.io.File; - -import net.i2p.router.Router; -import net.i2p.router.RouterContext; -import net.i2p.router.util.RFC822Date; -import net.i2p.util.EepGet; -import net.i2p.util.FileUtil; -import net.i2p.util.I2PAppThread; -import net.i2p.util.Log; - -/** - *

Handles the request to update the router by firing off an - * {@link net.i2p.util.EepGet} call to download the latest unsigned zip file - * and displaying the status to anyone who asks. - *

- *

After the download completes the signed update file is copied to the - * router directory, and if configured the router is restarted to complete - * the update process. - *

- */ -public class UnsignedUpdateHandler extends UpdateHandler { - private static UnsignedUpdateRunner _unsignedUpdateRunner; - private String _zipURL; - private String _zipVersion; - - public UnsignedUpdateHandler(RouterContext ctx, String zipURL, String version) { - super(ctx); - _zipURL = zipURL; - _zipVersion = version; - _updateFile = (new File(ctx.getTempDir(), "tmp" + ctx.random().nextInt() + Router.UPDATE_FILE)).getAbsolutePath(); - } - - @Override - public void update() { - // don't block waiting for the other one to finish - if ("true".equals(System.getProperty(PROP_UPDATE_IN_PROGRESS))) { - _log.error("Update already running"); - return; - } - synchronized (UpdateHandler.class) { - if (_unsignedUpdateRunner == null) { - _unsignedUpdateRunner = new UnsignedUpdateRunner(); - } - if (_unsignedUpdateRunner.isRunning()) { - return; - } else { - System.setProperty(PROP_UPDATE_IN_PROGRESS, "true"); - I2PAppThread update = new I2PAppThread(_unsignedUpdateRunner, "UnsignedUpdate"); - update.start(); - } - } - } - - /** - * Eepget the .zip file to the temp dir, then copy it over - */ - public class UnsignedUpdateRunner extends UpdateRunner implements Runnable, EepGet.StatusListener { - public UnsignedUpdateRunner() { - super(); - } - - /** Get the file */ - @Override - protected void update() { - updateStatus("" + _("Updating") + ""); - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Starting unsigned update URL: " + _zipURL); - // always proxy for now - //boolean shouldProxy = Boolean.valueOf(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)).booleanValue(); - String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); - int proxyPort = ConfigUpdateHandler.proxyPort(_context); - try { - // 40 retries!! - _get = new EepGet(_context, proxyHost, proxyPort, 40, _updateFile, _zipURL, false); - _get.addStatusListener(UnsignedUpdateRunner.this); - _get.fetch(CONNECT_TIMEOUT, -1, INACTIVITY_TIMEOUT); - } catch (Throwable t) { - _log.error("Error updating", t); - } - } - - /** eepget listener callback Overrides */ - @Override - public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { - File updFile = new File(_updateFile); - if (FileUtil.verifyZip(updFile)) { - updateStatus("" + _("Update downloaded") + ""); - } else { - updFile.delete(); - updateStatus("" + _("Unsigned update file from {0} is corrupt", url) + ""); - _log.log(Log.CRIT, "Corrupt zip file from " + url); - return; - } - File to = new File(_context.getRouterDir(), Router.UPDATE_FILE); - boolean copied = FileUtil.copy(updFile, to, true, false); - if (copied) { - updFile.delete(); - String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); - this.done = true; - String lastmod = _get.getLastModified(); - long modtime = 0; - if (lastmod != null) - modtime = RFC822Date.parse822Date(lastmod); - if (modtime <= 0) - modtime = _context.clock().now(); - _context.router().saveConfig(PROP_LAST_UPDATE_TIME, "" + modtime); - if ("install".equals(policy)) { - _log.log(Log.CRIT, "Update was downloaded, restarting to install it"); - updateStatus("" + _("Update downloaded") + "
" + _("Restarting")); - restart(); - } else { - _log.log(Log.CRIT, "Update was downloaded, will be installed at next restart"); - StringBuilder buf = new StringBuilder(64); - buf.append("").append(_("Update downloaded")).append("
"); - if (_context.hasWrapper()) - buf.append(_("Click Restart to install")); - else - buf.append(_("Click Shutdown and restart to install")); - buf.append(' ').append(_("Version {0}", _zipVersion)); - updateStatus(buf.toString()); - } - } else { - _log.log(Log.CRIT, "Failed copy to " + to); - updateStatus("" + _("Failed copy to {0}", to.getAbsolutePath()) + ""); - } - } - } -} diff --git a/apps/routerconsole/java/src/net/i2p/router/web/UpdateHandler.java b/apps/routerconsole/java/src/net/i2p/router/web/UpdateHandler.java index 2b87231bb6..412a907283 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/UpdateHandler.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/UpdateHandler.java @@ -1,25 +1,10 @@ package net.i2p.router.web; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.File; -import java.text.DecimalFormat; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.StringTokenizer; - -import net.i2p.crypto.TrustedUpdate; -import net.i2p.data.DataHelper; -import net.i2p.router.Router; import net.i2p.router.RouterContext; -import net.i2p.router.RouterVersion; -import net.i2p.router.util.RFC822Date; -import net.i2p.util.EepGet; -import net.i2p.util.I2PAppThread; +import net.i2p.router.update.ConsoleUpdateManager; +import net.i2p.update.UpdateType; +import static net.i2p.update.UpdateType.*; import net.i2p.util.Log; -import net.i2p.util.PartialEepGet; -import net.i2p.util.VersionComparator; /** *

Handles the request to update the router by firing one or more @@ -31,31 +16,22 @@ import net.i2p.util.VersionComparator; * of the signed update file is unpacked and the router is restarted to complete * the update process. *

+ * + * This is like a FormHandler but we don't extend it, as we don't have the message area, etc. */ public class UpdateHandler { - protected static UpdateRunner _updateRunner; protected RouterContext _context; protected Log _log; - protected String _updateFile; - private static String _status = ""; private String _action; private String _nonce; - protected static final String SIGNED_UPDATE_FILE = "i2pupdate.sud"; - static final String PROP_UPDATE_IN_PROGRESS = "net.i2p.router.web.UpdateHandler.updateInProgress"; - protected static final String PROP_LAST_UPDATE_TIME = "router.updateLastDownloaded"; - - protected static final long CONNECT_TIMEOUT = 55*1000; - protected static final long INACTIVITY_TIMEOUT = 5*60*1000; - protected static final long NOPROXY_INACTIVITY_TIMEOUT = 60*1000; - public UpdateHandler() { this(ContextHelper.getContext(null)); } + public UpdateHandler(RouterContext ctx) { _context = ctx; _log = ctx.logManager().getLog(UpdateHandler.class); - _updateFile = (new File(ctx.getRouterDir(), SIGNED_UPDATE_FILE)).getAbsolutePath(); } /** @@ -89,274 +65,21 @@ public class UpdateHandler { if (_nonce.equals(System.getProperty("net.i2p.router.web.UpdateHandler.nonce")) || _nonce.equals(System.getProperty("net.i2p.router.web.UpdateHandler.noncePrev"))) { if (_action.contains("Unsigned")) { - // Not us, have NewsFetcher instantiate the correct class. - NewsFetcher fetcher = NewsFetcher.getInstance(_context); - fetcher.fetchUnsigned(); + update(ROUTER_UNSIGNED); } else { - update(); + update(ROUTER_SIGNED); } } } - public void update() { - // don't block waiting for the other one to finish - if ("true".equals(System.getProperty(PROP_UPDATE_IN_PROGRESS))) { + private void update(UpdateType type) { + ConsoleUpdateManager mgr = (ConsoleUpdateManager) _context.updateManager(); + if (mgr == null) + return; + if (mgr.isUpdateInProgress(ROUTER_SIGNED) || mgr.isUpdateInProgress(ROUTER_UNSIGNED)) { _log.error("Update already running"); return; } - synchronized (UpdateHandler.class) { - if (_updateRunner == null) - _updateRunner = new UpdateRunner(); - if (_updateRunner.isRunning()) { - return; - } else { - System.setProperty(PROP_UPDATE_IN_PROGRESS, "true"); - I2PAppThread update = new I2PAppThread(_updateRunner, "SignedUpdate"); - update.start(); - } - } + mgr.update(type); } - - public static String getStatus() { - return _status; - } - - public boolean isDone() { - return false; - // this needs to be fixed and tested - //if(this._updateRunner == null) - // return true; - //return this._updateRunner.isDone(); - } - - public class UpdateRunner implements Runnable, EepGet.StatusListener { - protected volatile boolean _isRunning; - protected boolean done; - protected EepGet _get; - protected final DecimalFormat _pct = new DecimalFormat("0.0%"); - /** tells the listeners what mode we are in */ - private boolean _isPartial; - /** set by the listeners on completion */ - private boolean _isNewer; - private ByteArrayOutputStream _baos; - - public UpdateRunner() { - _isRunning = false; - this.done = false; - updateStatus("" + _("Updating") + ""); - } - public boolean isRunning() { return _isRunning; } - public boolean isDone() { - return this.done; - } - public void run() { - _isRunning = true; - update(); - System.setProperty(PROP_UPDATE_IN_PROGRESS, "false"); - _isRunning = false; - } - - /** - * Loop through the entire list of update URLs. - * For each one, first get the version from the first 56 bytes and see if - * it is newer than what we are running now. - * If it is, get the whole thing. - */ - protected void update() { - // Do a PartialEepGet on the selected URL, check for version we expect, - // and loop if it isn't what we want. - // This will allows us to do a release without waiting for the last host to install the update. - // Alternative: In bytesTransferred(), Check the data in the output file after - // we've received at least 56 bytes. Need a cancel() method in EepGet ? - - boolean shouldProxy = Boolean.parseBoolean(_context.getProperty(ConfigUpdateHandler.PROP_SHOULD_PROXY, ConfigUpdateHandler.DEFAULT_SHOULD_PROXY)); - String proxyHost = _context.getProperty(ConfigUpdateHandler.PROP_PROXY_HOST, ConfigUpdateHandler.DEFAULT_PROXY_HOST); - int proxyPort = ConfigUpdateHandler.proxyPort(_context); - - List urls = getUpdateURLs(); - if (urls.isEmpty()) { - // not likely, don't bother translating - updateStatus("Update source list is empty, cannot download update"); - _log.log(Log.CRIT, "Update source list is empty - cannot download update"); - return; - } - - if (shouldProxy) - _baos = new ByteArrayOutputStream(TrustedUpdate.HEADER_BYTES); - for (String updateURL : urls) { - updateStatus("" + _("Updating from {0}", linkify(updateURL)) + ""); - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Selected update URL: " + updateURL); - - // Check the first 56 bytes for the version - if (shouldProxy) { - _isPartial = true; - _isNewer = false; - _baos.reset(); - try { - // no retries - _get = new PartialEepGet(_context, proxyHost, proxyPort, _baos, updateURL, TrustedUpdate.HEADER_BYTES); - _get.addStatusListener(UpdateRunner.this); - _get.fetch(CONNECT_TIMEOUT); - } catch (Throwable t) { - _isNewer = false; - } - _isPartial = false; - if (!_isNewer) - continue; - } - - // Now get the whole thing - try { - if (shouldProxy) - // 40 retries!! - _get = new EepGet(_context, proxyHost, proxyPort, 40, _updateFile, updateURL, false); - else - _get = new EepGet(_context, 1, _updateFile, updateURL, false); - _get.addStatusListener(UpdateRunner.this); - _get.fetch(CONNECT_TIMEOUT, -1, shouldProxy ? INACTIVITY_TIMEOUT : NOPROXY_INACTIVITY_TIMEOUT); - } catch (Throwable t) { - _log.error("Error updating", t); - } - if (this.done) - break; - } - } - - // EepGet Listeners below. - // We use the same for both the partial and the full EepGet, - // with a couple of adjustments depending on which mode. - - public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) { - _isNewer = false; - if (_log.shouldLog(Log.DEBUG)) - _log.debug("Attempt failed on " + url, cause); - // ignored - } - public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) { - if (_isPartial) - return; - StringBuilder buf = new StringBuilder(64); - double pct = ((double)alreadyTransferred + (double)currentWrite) / - ((double)alreadyTransferred + (double)currentWrite + bytesRemaining); - synchronized (_pct) { - buf.append(_("{0} downloaded", _pct.format(pct))); - } - buf.append("
\n"); - buf.append(DataHelper.formatSize2(currentWrite + alreadyTransferred)) - .append("B / ") - .append(DataHelper.formatSize2(currentWrite + alreadyTransferred + bytesRemaining)) - .append("B"); - updateStatus(buf.toString()); - } - public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) { - if (_isPartial) { - // Compare version with what we have now - String newVersion = TrustedUpdate.getVersionString(new ByteArrayInputStream(_baos.toByteArray())); - boolean newer = (new VersionComparator()).compare(newVersion, RouterVersion.VERSION) > 0; - if (!newer) { - updateStatus("" + _("No new version found at {0}", linkify(url)) + ""); - if (_log.shouldLog(Log.WARN)) - _log.warn("Found old version \"" + newVersion + "\" at " + url); - } - _isNewer = newer; - return; - } - // Process the .sud/.su2 file - updateStatus("" + _("Update downloaded") + ""); - TrustedUpdate up = new TrustedUpdate(_context); - File f = new File(_updateFile); - File to = new File(_context.getRouterDir(), Router.UPDATE_FILE); - String err = up.migrateVerified(RouterVersion.VERSION, f, to); - f.delete(); - if (err == null) { - String policy = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_POLICY); - this.done = true; - // So unsigned update handler doesn't overwrite unless newer. - String lastmod = _get.getLastModified(); - long modtime = 0; - if (lastmod != null) - modtime = RFC822Date.parse822Date(lastmod); - if (modtime <= 0) - modtime = _context.clock().now(); - _context.router().saveConfig(PROP_LAST_UPDATE_TIME, "" + modtime); - if ("install".equals(policy)) { - _log.log(Log.CRIT, "Update was VERIFIED, restarting to install it"); - updateStatus("" + _("Update verified") + "
" + _("Restarting")); - restart(); - } else { - _log.log(Log.CRIT, "Update was VERIFIED, will be installed at next restart"); - StringBuilder buf = new StringBuilder(64); - buf.append("").append(_("Update downloaded")).append("
"); - if (_context.hasWrapper()) - buf.append(_("Click Restart to install")); - else - buf.append(_("Click Shutdown and restart to install")); - if (up.newVersion() != null) - buf.append(' ').append(_("Version {0}", up.newVersion())); - buf.append(""); - updateStatus(buf.toString()); - } - } else { - _log.log(Log.CRIT, err + " from " + url); - updateStatus("" + err + ' ' + _("from {0}", linkify(url)) + " "); - } - } - public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) { - _isNewer = false; - // don't display bytesTransferred as it is meaningless - _log.error("Update from " + url + " did not download completely (" + - bytesRemaining + " remaining after " + currentAttempt + " tries)"); - - updateStatus("" + _("Transfer failed from {0}", linkify(url)) + ""); - } - public void headerReceived(String url, int attemptNum, String key, String val) {} - public void attempting(String url) {} - } - - protected void restart() { - if (_context.hasWrapper()) - ConfigServiceHandler.registerWrapperNotifier(_context, Router.EXIT_GRACEFUL_RESTART, false); - _context.router().shutdownGracefully(Router.EXIT_GRACEFUL_RESTART); - } - - private List getUpdateURLs() { - String URLs = _context.getProperty(ConfigUpdateHandler.PROP_UPDATE_URL, ConfigUpdateHandler.DEFAULT_UPDATE_URL); - StringTokenizer tok = new StringTokenizer(URLs, " ,\r\n"); - List URLList = new ArrayList(); - while (tok.hasMoreTokens()) - URLList.add(tok.nextToken().trim()); - Collections.shuffle(URLList, _context.random()); - return URLList; - } - - protected void updateStatus(String s) { - _status = s; - } - - protected static String linkify(String url) { - return "" + url + ""; - } - - /** translate a string */ - protected String _(String s) { - return Messages.getString(s, _context); - } - - /** - * translate a string with a parameter - * This is a lot more expensive than _(s), so use sparingly. - * - * @param s string to be translated containing {0} - * The {0} will be replaced by the parameter. - * Single quotes must be doubled, i.e. ' -> '' in the string. - * @param o parameter, not translated. - * To tranlslate parameter also, use _("foo {0} bar", _("baz")) - * Do not double the single quotes in the parameter. - * Use autoboxing to call with ints, longs, floats, etc. - */ - protected String _(String s, Object o) { - return Messages.getString(s, o, _context); - } - } diff --git a/apps/routerconsole/java/src/net/i2p/router/web/WebAppConfiguration.java b/apps/routerconsole/java/src/net/i2p/router/web/WebAppConfiguration.java index 98ca931133..5afa5d2db0 100644 --- a/apps/routerconsole/java/src/net/i2p/router/web/WebAppConfiguration.java +++ b/apps/routerconsole/java/src/net/i2p/router/web/WebAppConfiguration.java @@ -64,7 +64,7 @@ public class WebAppConfiguration implements Configuration { File libDir = new File(i2pContext.getBaseDir(), "lib"); // FIXME this only works if war is the same name as the plugin File pluginDir = new File(i2pContext.getConfigDir(), - PluginUpdateHandler.PLUGIN_DIR + ctxPath); + PluginStarter.PLUGIN_DIR + ctxPath); File dir = libDir; String cp; diff --git a/core/java/build.xml b/core/java/build.xml index a415e7954f..c52df80d31 100644 --- a/core/java/build.xml +++ b/core/java/build.xml @@ -81,14 +81,15 @@ - + + - + @@ -102,6 +103,23 @@ + + + + + + + + + + + + + + + + + diff --git a/core/java/src/net/i2p/I2PAppContext.java b/core/java/src/net/i2p/I2PAppContext.java index bd1085f180..05475eea00 100644 --- a/core/java/src/net/i2p/I2PAppContext.java +++ b/core/java/src/net/i2p/I2PAppContext.java @@ -26,6 +26,7 @@ import net.i2p.data.Base64; import net.i2p.data.RoutingKeyGenerator; import net.i2p.internal.InternalClientManager; import net.i2p.stat.StatManager; +import net.i2p.update.UpdateManager; import net.i2p.util.Clock; import net.i2p.util.ConcurrentHashSet; import net.i2p.util.FileUtil; @@ -991,4 +992,13 @@ public class I2PAppContext { _simpleTimer2Initialized = true; } } + + /** + * The controller of router, plugin, and other updates. + * @return always null in I2PAppContext, the update manager if in RouterContext and it is registered + * @since 0.9.2 + */ + public UpdateManager updateManager() { + return null; + } } diff --git a/core/java/src/net/i2p/update/UpdateManager.java b/core/java/src/net/i2p/update/UpdateManager.java new file mode 100644 index 0000000000..4099822bcc --- /dev/null +++ b/core/java/src/net/i2p/update/UpdateManager.java @@ -0,0 +1,79 @@ +package net.i2p.update; + +import java.io.File; +import java.net.URI; +import java.util.List;; + +/** + * The central resource coordinating updates. + * This must be registered with the context. + * + * The UpdateManager starts and stops all updates, + * and controls notification to the user. + * + * @since 0.9.2 + */ +public interface UpdateManager { + + /** + * Call multiple times for each type/method pair. + * The UpdateManager will then call start() + */ + public void register(Updater updater, UpdateType type, UpdateMethod method, int priority); + + public void unregister(Updater updater, UpdateType type, UpdateMethod method); + + public void start(); + + public void shutdown(); + + /** + * Called by the Updater, either after check() was called, or it found out on its own. + * + * @param newsSource who told us + * @param id plugin name for plugins, ignored otherwise + * @param method How to get the new version + * @param updateSourcew Where to get the new version + * @param newVersion The new version available + * @param minVersion The minimum installed version to be able to update to newVersion + * @return true if we didn't know already + */ + public boolean notifyVersionAvailable(UpdateTask task, URI newsSource, + UpdateType type, String id, + UpdateMethod method, List updateSources, + String newVersion, String minVersion); + + /** + * Called by the Updater after check() was called and all notifyVersionAvailable() callbacks are finished + * @param newer notifyVersionAvailable was called + * @param success check succeeded (newer or not) + */ + public void notifyCheckComplete(UpdateTask task, boolean newer, boolean success); + + public void notifyProgress(UpdateTask task, String status); + public void notifyProgress(UpdateTask task, String status, long downloaded, long totalSize); + + /** + * Not necessarily the end if there are more URIs to try. + * @param t may be null + */ + public void notifyAttemptFailed(UpdateTask task, String reason, Throwable t); + + /** + * The task has finished and failed. + * @param t may be null + */ + public void notifyTaskFailed(UpdateTask task, String reason, Throwable t); + + /** + * An update has been downloaded but not verified. + * The manager will verify it. + * Caller should delete the file upon return, unless it will share it with others, + * e.g. on a torrent. + * + * @param actualVersion may be higher (or lower?) than the version requested + * @param file a valid format for the task's UpdateType + * @return true if valid, false if corrupt + */ + public boolean notifyComplete(UpdateTask task, String actualVersion, File file); +} diff --git a/core/java/src/net/i2p/update/UpdateMethod.java b/core/java/src/net/i2p/update/UpdateMethod.java new file mode 100644 index 0000000000..6d30bc99c8 --- /dev/null +++ b/core/java/src/net/i2p/update/UpdateMethod.java @@ -0,0 +1,15 @@ +package net.i2p.update; + +/** + * Transport mechanism for getting something. + * + * @since 0.9.2 + */ +public enum UpdateMethod { + METHOD_DUMMY, + HTTP, // .i2p or via outproxy + HTTP_CLEARNET, // direct non-.i2p + TORRENT, + GNUTELLA, IMULE, TAHOE_LAFS, + DEBIAN +} diff --git a/core/java/src/net/i2p/update/UpdateTask.java b/core/java/src/net/i2p/update/UpdateTask.java new file mode 100644 index 0000000000..b9237b3ee6 --- /dev/null +++ b/core/java/src/net/i2p/update/UpdateTask.java @@ -0,0 +1,30 @@ +package net.i2p.update; + +import java.net.URI; + +/** + * A running check or download. Cannot be restarted. + * + * @since 0.9.2 + */ +public interface UpdateTask { + + public void shutdown(); + + public boolean isRunning(); + + public UpdateType getType(); + + public UpdateMethod getMethod(); + + /** + * The current URI being checked or downloaded from. + * Can change if there are multiple URIs to try. + */ + public URI getURI(); + + /** + * Valid for plugins + */ + public String getID(); +} diff --git a/core/java/src/net/i2p/update/UpdateType.java b/core/java/src/net/i2p/update/UpdateType.java new file mode 100644 index 0000000000..f16eaad7d2 --- /dev/null +++ b/core/java/src/net/i2p/update/UpdateType.java @@ -0,0 +1,16 @@ +package net.i2p.update; + +/** + * What to update + * + * @since 0.9.2 + */ +public enum UpdateType { + TYPE_DUMMY, + NEWS, + ROUTER_SIGNED, + ROUTER_SIGNED_PACK200, // unused, use ROUTER_SIGNED for both + ROUTER_UNSIGNED, + PLUGIN, PLUGIN_INSTALL, + GEOIP, BLOCKLIST, RESEED +} diff --git a/core/java/src/net/i2p/update/Updater.java b/core/java/src/net/i2p/update/Updater.java new file mode 100644 index 0000000000..bea1a778db --- /dev/null +++ b/core/java/src/net/i2p/update/Updater.java @@ -0,0 +1,36 @@ +package net.i2p.update; + +import java.net.URI; +import java.util.List; + +/** + * Controls one or more types of updates. + * This must be registered with the UpdateManager. + * + * @since 0.9.2 + */ +public interface Updater { + + /** + * Check for updates. + * Should not block. + * If any are found, call back to UpdateManager.notifyUpdateAvailable(). + * + * @param id plugin name or ignored + * @param maxTime how long you have + * @return active task or null if unable to check + */ + public UpdateTask check(UpdateType type, UpdateMethod method, + String id, String currentVersion, long maxTime); + + /** + * Start a download and return a handle to the download task. + * Should not block. + * + * @param id plugin name or ignored + * @param maxTime how long you have + * @return active task or null if unable to download + */ + public UpdateTask update(UpdateType type, UpdateMethod method, List updateSources, + String id, String newVersion, long maxTime); +} diff --git a/core/java/src/net/i2p/update/package.html b/core/java/src/net/i2p/update/package.html new file mode 100644 index 0000000000..20e06658ea --- /dev/null +++ b/core/java/src/net/i2p/update/package.html @@ -0,0 +1,8 @@ + + +

+Interfaces for classes to assist in the update process without +needing the router context. +

+ + diff --git a/core/java/src/net/i2p/util/VersionComparator.java b/core/java/src/net/i2p/util/VersionComparator.java index 3b6e97f5b4..8c72252fcb 100644 --- a/core/java/src/net/i2p/util/VersionComparator.java +++ b/core/java/src/net/i2p/util/VersionComparator.java @@ -22,7 +22,7 @@ public class VersionComparator implements Comparator { while (lTokens.hasMoreTokens() && rTokens.hasMoreTokens()) { String lNumber = lTokens.nextToken(); String rNumber = rTokens.nextToken(); - int diff = intCompare(lNumber, rNumber); + int diff = longCompare(lNumber, rNumber); if (diff != 0) return diff; } @@ -34,19 +34,24 @@ public class VersionComparator implements Comparator { return 0; } - private static final int intCompare(String lop, String rop) { - int left, right; + private static final int longCompare(String lop, String rop) { + long left, right; try { - left = Integer.parseInt(lop); + left = Long.parseLong(lop); } catch (NumberFormatException nfe) { return -1; } try { - right = Integer.parseInt(rop); + right = Long.parseLong(rop); } catch (NumberFormatException nfe) { return 1; } - return left - right; + long diff = left - right; + if (diff < 0) + return -1; + if (diff > 0) + return 1; + return 0; } private static final String VALID_SEPARATOR_CHARS = ".-_"; diff --git a/router/java/build.xml b/router/java/build.xml index 83f23fa444..6b49c9530c 100644 --- a/router/java/build.xml +++ b/router/java/build.xml @@ -99,18 +99,23 @@ + + + + - + + - - + + @@ -124,6 +129,23 @@ + + + + + + + + + + + + + + + + + diff --git a/router/java/src/net/i2p/router/RouterContext.java b/router/java/src/net/i2p/router/RouterContext.java index 421539ce3f..51af505543 100644 --- a/router/java/src/net/i2p/router/RouterContext.java +++ b/router/java/src/net/i2p/router/RouterContext.java @@ -23,6 +23,7 @@ import net.i2p.router.transport.FIFOBandwidthLimiter; import net.i2p.router.transport.OutboundMessageRegistry; import net.i2p.router.tunnel.TunnelDispatcher; import net.i2p.router.tunnel.pool.TunnelPoolManager; +import net.i2p.update.UpdateManager; import net.i2p.util.KeyRing; import net.i2p.util.I2PProperties.I2PPropertyCallback; @@ -56,11 +57,12 @@ public class RouterContext extends I2PAppContext { private Shitlist _shitlist; private Blocklist _blocklist; private MessageValidator _messageValidator; + private UpdateManager _updateManager; //private MessageStateMonitor _messageStateMonitor; private RouterThrottle _throttle; private final Set _finalShutdownTasks; // split up big lock on this to avoid deadlocks - private final Object _lock1 = new Object(), _lock2 = new Object(); + private final Object _lock1 = new Object(), _lock2 = new Object(), _lock3 = new Object(); private static final List _contexts = new CopyOnWriteArrayList(); @@ -483,6 +485,7 @@ public class RouterContext extends I2PAppContext { * @return true * @since 0.7.9 */ + @Override public boolean isRouterContext() { return true; } @@ -492,7 +495,44 @@ public class RouterContext extends I2PAppContext { * @return the client manager * @since 0.8.3 */ + @Override public InternalClientManager internalClientManager() { return _clientManagerFacade; } + + /** + * The controller of router, plugin, and other updates. + * @return The manager if it is registered, else null + * @since 0.9.2 + */ + @Override + public UpdateManager updateManager() { + return _updateManager; + } + + /** + * Register as the update manager. + * @throws IllegalStateException if one was already registered + * @since 0.9.2 + */ + public void registerUpdateManager(UpdateManager mgr) { + synchronized(_lock3) { + if (_updateManager != null) + throw new IllegalStateException(); + _updateManager = mgr; + } + } + + /** + * Unregister the update manager. + * @throws IllegalStateException if it was not registered + * @since 0.9.2 + */ + public void unregisterUpdateManager(UpdateManager mgr) { + synchronized(_lock3) { + if (_updateManager != mgr) + throw new IllegalStateException(); + _updateManager = null; + } + } }