src/main/java/net/pterodactylus/sone/core/UpdateChecker.java

   1 /*
   2  * Sone - UpdateChecker.java - Copyright © 2011–2019 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.sone.core;
  19
  20 import static java.util.logging.Logger.getLogger;
  21
  22 import java.io.IOException;
  23 import java.io.InputStream;
  24 import java.io.InputStreamReader;
  25 import java.net.MalformedURLException;
  26 import java.util.Date;
  27 import java.util.Properties;
  28 import java.util.logging.Level;
  29 import java.util.logging.Logger;
  30
  31 import javax.inject.Singleton;
  32
  33 import net.pterodactylus.sone.core.event.UpdateFoundEvent;
  34 import net.pterodactylus.sone.main.PluginHomepage;
  35 import net.pterodactylus.sone.main.SonePlugin;
  36 import net.pterodactylus.util.io.Closer;
  37 import net.pterodactylus.util.version.Version;
  38
  39 import com.google.common.eventbus.EventBus;
  40 import com.google.inject.Inject;
  41
  42 import freenet.keys.FreenetURI;
  43 import freenet.support.api.Bucket;
  44
  45 /**
  46  * Watches the official Sone homepage for new releases.
  47  */
  48 @Singleton
  49 public class UpdateChecker {
  50
  51         /** The logger. */
  52         private static final Logger logger = getLogger(UpdateChecker.class.getName());
  53
  54         /** The event bus. */
  55         private final EventBus eventBus;
  56
  57         /** The Freenet interface. */
  58         private final FreenetInterface freenetInterface;
  59
  60         /** The current URI of the homepage. */
  61         private FreenetURI currentUri;
  62
  63         /** The latest known edition. */
  64         private long latestEdition = SonePlugin.getLatestEdition();
  65
  66         /** The current latest known version. */
  67         private Version currentLatestVersion;
  68         private final Version currentRunningVersion;
  69
  70         /** The release date of the latest version. */
  71         private long latestVersionDate;
  72
  73         private final PluginHomepage pluginHomepage;
  74
  75         /**
  76          * Creates a new update checker.
  77          *
  78          * @param eventBus
  79          *            The event bus
  80          * @param freenetInterface
  81          *            The freenet interface to use
  82          */
  83         @Inject
  84         public UpdateChecker(EventBus eventBus, FreenetInterface freenetInterface, Version currentVersion, PluginHomepage pluginHomepage) {
  85                 this.eventBus = eventBus;
  86                 this.freenetInterface = freenetInterface;
  87                 this.currentRunningVersion = currentVersion;
  88                 this.currentLatestVersion = currentVersion;
  89                 this.pluginHomepage = pluginHomepage;
  90         }
  91
  92         //
  93         // ACCESSORS
  94         //
  95
  96         /**
  97          * Returns whether a version that is later than the currently running
  98          * version has been found.
  99          *
 100          * @return {@code true} if a new version was found
 101          */
 102         public boolean hasLatestVersion() {
 103                 return currentLatestVersion.compareTo(currentRunningVersion) > 0;
 104         }
 105
 106         /**
 107          * Returns the latest version. If no new latest version has been found, the
 108          * current version is returned.
 109          *
 110          * @return The latest known version
 111          */
 112         public Version getLatestVersion() {
 113                 return currentLatestVersion;
 114         }
 115
 116         /**
 117          * Returns the release time of the latest version. If no new latest version
 118          * has been found, the returned value is undefined.
 119          *
 120          * @return The release time of the latest version, if a new version was
 121          *         found
 122          */
 123         public long getLatestVersionDate() {
 124                 return latestVersionDate;
 125         }
 126
 127         /**
 128          * Returns the latest known edition of the Sone homepage.
 129          *
 130          * @return The latest edition of the Sone homepage
 131          */
 132         public long getLatestEdition() {
 133                 return latestEdition;
 134         }
 135
 136         //
 137         // ACTIONS
 138         //
 139
 140         /**
 141          * Starts the update checker.
 142          */
 143         public void start() {
 144                 try {
 145                         currentUri = new FreenetURI(pluginHomepage.getHomepage());
 146                 } catch (MalformedURLException mue1) {
 147                         /* this can not really happen unless I screw up. */
 148                         logger.log(Level.SEVERE, "Sone Homepage URI invalid!", mue1);
 149                 }
 150                 freenetInterface.registerUsk(currentUri, new FreenetInterface.Callback() {
 151
 152                         @Override
 153                         @SuppressWarnings("synthetic-access")
 154                         public void editionFound(FreenetURI uri, long edition, boolean newKnownGood, boolean newSlot) {
 155                                 logger.log(Level.FINEST, String.format("Found update for %s: %d, %s, %s", uri, edition, newKnownGood, newSlot));
 156                                 if (newKnownGood || newSlot) {
 157                                         Fetched uriResult = freenetInterface.fetchUri(uri.setMetaString(new String[] { "sone.properties" }));
 158                                         if (uriResult == null) {
 159                                                 logger.log(Level.WARNING, String.format("Could not fetch properties of latest homepage: %s", uri));
 160                                                 return;
 161                                         }
 162                                         Bucket resultBucket = uriResult.getFetchResult().asBucket();
 163                                         try {
 164                                                 parseProperties(resultBucket.getInputStream(), edition);
 165                                                 latestEdition = edition;
 166                                         } catch (IOException ioe1) {
 167                                                 logger.log(Level.WARNING, String.format("Could not parse sone.properties of %s!", uri), ioe1);
 168                                         } finally {
 169                                                 resultBucket.free();
 170                                         }
 171                                 }
 172                         }
 173                 });
 174         }
 175
 176         /**
 177          * Stops the update checker.
 178          */
 179         public void stop() {
 180                 freenetInterface.unregisterUsk(currentUri);
 181         }
 182
 183         //
 184         // PRIVATE ACTIONS
 185         //
 186
 187         /**
 188          * Parses the properties of the latest version and fires events, if
 189          * necessary.
 190          *
 191          * @see UpdateFoundEvent
 192          * @param propertiesInputStream
 193          *            The input stream to parse
 194          * @param edition
 195          *            The latest edition of the Sone homepage
 196          * @throws IOException
 197          *             if an I/O error occured
 198          */
 199         private void parseProperties(InputStream propertiesInputStream, long edition) throws IOException {
 200                 Properties properties = new Properties();
 201                 InputStreamReader inputStreamReader = null;
 202                 try {
 203                         inputStreamReader = new InputStreamReader(propertiesInputStream, "UTF-8");
 204                         properties.load(inputStreamReader);
 205                 } finally {
 206                         Closer.close(inputStreamReader);
 207                 }
 208                 String versionString = properties.getProperty("CurrentVersion/Version");
 209                 String releaseTimeString = properties.getProperty("CurrentVersion/ReleaseTime");
 210                 if ((versionString == null) || (releaseTimeString == null)) {
 211                         logger.log(Level.INFO, "Invalid data parsed from properties.");
 212                         return;
 213                 }
 214                 Version version = Version.parse(versionString);
 215                 long releaseTime = 0;
 216                 try {
 217                         releaseTime = Long.parseLong(releaseTimeString);
 218                 } catch (NumberFormatException nfe1) {
 219                         /* ignore. */
 220                 }
 221                 if ((version == null) || (releaseTime == 0)) {
 222                         logger.log(Level.INFO, "Could not parse data from properties.");
 223                         return;
 224                 }
 225                 if (version.compareTo(currentLatestVersion) > 0) {
 226                         currentLatestVersion = version;
 227                         latestVersionDate = releaseTime;
 228                         boolean disruptive = disruptiveVersionBetweenCurrentAndFound(properties);
 229                         logger.log(Level.INFO, String.format("Found new version: %s (%tc%s)", version, new Date(releaseTime), disruptive ? ", disruptive" : ""));
 230                         eventBus.post(new UpdateFoundEvent(version, releaseTime, edition, disruptive));
 231                 }
 232         }
 233
 234         private boolean disruptiveVersionBetweenCurrentAndFound(Properties properties) {
 235                 for (String key : properties.stringPropertyNames()) {
 236                         if (key.startsWith("DisruptiveVersion/")) {
 237                                 Version disruptiveVersion = Version.parse(key.substring("DisruptiveVersion/".length()));
 238                                 if (disruptiveVersion.compareTo(currentRunningVersion) > 0) {
 239                                         return true;
 240                                 }
 241                         }
 242                 }
 243                 return false;
 244         }
 245
 246 }