X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FCore.java;h=941710cd3ebe07be8925accb447a96071a3a9c93;hb=9d6e64f8548fd45e06a492d0b92099c27fddd378;hp=21d7a808aa050cdf5dfdd497fc3bf9ac4cce2cb2;hpb=e0f1723814bdfd94f75dd9ad11462124cdcb8a6c;p=Sone.git diff --git a/src/main/java/net/pterodactylus/sone/core/Core.java b/src/main/java/net/pterodactylus/sone/core/Core.java index 21d7a80..941710c 100644 --- a/src/main/java/net/pterodactylus/sone/core/Core.java +++ b/src/main/java/net/pterodactylus/sone/core/Core.java @@ -17,6 +17,7 @@ package net.pterodactylus.sone.core; +import java.io.InputStream; import java.net.MalformedURLException; import java.util.ArrayList; import java.util.Collection; @@ -90,6 +91,9 @@ public class Core extends AbstractService { /** The Sone downloader. */ private SoneDownloader soneDownloader; + /** The Sone blacklist. */ + private final Set blacklistedSones = new HashSet(); + /** The local Sones. */ private final Set localSones = new HashSet(); @@ -162,7 +166,17 @@ public class Core extends AbstractService { * @return The local Sones */ public Set getSones() { - return Collections.unmodifiableSet(localSones); + return Filters.filteredSet(localSones, new Filter() { + + /** + * {@inheritDoc} + */ + @Override + @SuppressWarnings("synthetic-access") + public boolean filterObject(Sone sone) { + return !blacklistedSones.contains(sone); + } + }); } /** @@ -188,7 +202,17 @@ public class Core extends AbstractService { * @return All known sones */ public Collection getKnownSones() { - return soneCache.values(); + return Filters.filteredCollection(soneCache.values(), new Filter() { + + /** + * {@inheritDoc} + */ + @Override + @SuppressWarnings("synthetic-access") + public boolean filterObject(Sone sone) { + return !blacklistedSones.contains(sone); + } + }); } /** @@ -201,13 +225,33 @@ public class Core extends AbstractService { @Override @SuppressWarnings("synthetic-access") - public boolean filterObject(Sone object) { - return !localSones.contains(object); + public boolean filterObject(Sone sone) { + return !blacklistedSones.contains(sone) && !localSones.contains(sone); } }); } /** + * Returns all blacklisted Sones. + * + * @return All blacklisted Sones + */ + public Collection getBlacklistedSones() { + return Collections.unmodifiableCollection(blacklistedSones); + } + + /** + * Checks whether the given Sone is blacklisted. + * + * @param sone + * The Sone to check + * @return {@code true} if this Sone is blacklisted, {@code false} otherwise + */ + public boolean isBlacklistedSone(Sone sone) { + return blacklistedSones.contains(sone); + } + + /** * Returns the status of the given Sone. * * @param sone @@ -328,6 +372,38 @@ public class Core extends AbstractService { } /** + * Blackslists the given Sone. + * + * @param sone + * The Sone to blacklist + */ + public void blacklistSone(Sone sone) { + if (blacklistedSones.add(sone)) { + soneDownloader.removeSone(sone); + if (localSones.remove(sone)) { + SoneInserter soneInserter = soneInserters.remove(sone); + soneInserter.stop(); + } + } + } + + /** + * Unblacklists the given Sone. + * + * @param sone + * The Sone to unblacklist + */ + public void unblacklistSone(Sone sone) { + if (blacklistedSones.remove(sone)) { + if (sone.getInsertUri() != null) { + addLocalSone(sone); + } else { + addSone(sone); + } + } + } + + /** * Creates a new Sone at a random location. * * @param name @@ -438,6 +514,26 @@ public class Core extends AbstractService { } /** + * Loads a Sone from an input stream. + * + * @param soneInputStream + * The input stream to load the Sone from + * @return The parsed Sone, or {@code null} if the Sone could not be parsed + */ + public Sone loadSone(InputStream soneInputStream) { + Sone parsedSone = soneDownloader.parseSone(soneInputStream); + if (parsedSone == null) { + return null; + } + if (parsedSone.getInsertUri() != null) { + addLocalSone(parsedSone); + } else { + addSone(parsedSone); + } + return parsedSone; + } + + /** * Loads and updates the given Sone. * * @param sone @@ -615,6 +711,7 @@ public class Core extends AbstractService { /** * Loads the configuration. */ + @SuppressWarnings("unchecked") private void loadConfiguration() { logger.entering(Core.class.getName(), "loadConfiguration()"); @@ -625,7 +722,20 @@ public class Core extends AbstractService { SoneInserter.setInsertionDelay(newValue); } - })).set(configuration.getIntValue("Option/InsertionDelay").getValue(null)); + })); + + options.addBooleanOption("ClearOnNextRestart", new DefaultOption(false)).set(configuration.getBooleanValue("Option/ClearOnNextRestart").getValue(null)); + options.addBooleanOption("ReallyClearOnNextRestart", new DefaultOption(false)).set(configuration.getBooleanValue("Option/ReallyClearOnNextRestart").getValue(null)); + + boolean clearConfiguration = options.getBooleanOption("ClearOnNextRestart").get() && options.getBooleanOption("ReallyClearOnNextRestart").get(); + options.getBooleanOption("ClearOnNextRestart").set(null); + options.getBooleanOption("ReallyClearOnNextRestart").set(null); + if (clearConfiguration) { + /* stop loading the configuration. */ + return; + } + + options.getIntegerOption("InsertionDelay").set(configuration.getIntValue("Option/InsertionDelay").getValue(null)); /* parse local Sones. */ logger.log(Level.INFO, "Loading Sones…"); @@ -754,6 +864,23 @@ public class Core extends AbstractService { } } + /* load all blacklisted Sones. */ + int blacklistedSonesCounter = 0; + while (true) { + String blacklistedSonePrefix = "BlacklistedSone." + blacklistedSonesCounter++; + String blacklistedSoneId = configuration.getStringValue(blacklistedSonePrefix + "/ID").getValue(null); + if (blacklistedSoneId == null) { + break; + } + String blacklistedSoneName = configuration.getStringValue(blacklistedSonePrefix + "/Name").getValue(null); + String blacklistedSoneKey = configuration.getStringValue(blacklistedSonePrefix + "/Key").getValue(null); + try { + blacklistSone(getSone(blacklistedSoneId).setName(blacklistedSoneName).setRequestUri(new FreenetURI(blacklistedSoneKey))); + } catch (MalformedURLException mue1) { + logger.log(Level.WARNING, "Could not create blacklisted Sone from requestUri (“" + blacklistedSoneKey + "”)!", mue1); + } + } + /* load all remote Sones. */ for (Sone remoteSone : getRemoteSones()) { loadSone(remoteSone); @@ -772,6 +899,8 @@ public class Core extends AbstractService { try { /* store the options first. */ configuration.getIntValue("Option/InsertionDelay").setValue(options.getIntegerOption("InsertionDelay").getReal()); + configuration.getBooleanValue("Option/ClearOnNextRestart").setValue(options.getBooleanOption("ClearOnNextRestart").getReal()); + configuration.getBooleanValue("Option/ReallyClearOnNextRestart").setValue(options.getBooleanOption("ReallyClearOnNextRestart").getReal()); /* store all Sones. */ int soneId = 0; @@ -860,6 +989,17 @@ public class Core extends AbstractService { } configuration.getStringValue("KnownSone." + knownSonesCounter + "/ID").setValue(null); + /* write all blacklisted Sones. */ + int blacklistedSonesCounter = 0; + for (Sone blacklistedSone : getBlacklistedSones()) { + String blacklistedSonePrefix = "BlacklistedSone." + blacklistedSonesCounter++; + configuration.getStringValue(blacklistedSonePrefix + "/ID").setValue(blacklistedSone.getId()); + configuration.getStringValue(blacklistedSonePrefix + "/Name").setValue(blacklistedSone.getName()); + configuration.getStringValue(blacklistedSonePrefix + "/Key").setValue(blacklistedSone.getRequestUri().toString()); + /* TODO - store all known stuff? */ + } + configuration.getStringValue("BlacklistedSone." + blacklistedSonesCounter + "/ID").setValue(null); + } catch (ConfigurationException ce1) { logger.log(Level.WARNING, "Could not store configuration!", ce1); }