X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FCore.java;h=53b67000d1ac96fb06ff0068561f41435b072b19;hp=dbda28d7f0c3960e5e9800549f27f5855a217ed1;hb=63a1491b93ba8c2541ff92aab80e27cd41eda2fb;hpb=6004444a6a2f604b46d1440cd7f0fbe6502245d5 diff --git a/src/main/java/net/pterodactylus/sone/core/Core.java b/src/main/java/net/pterodactylus/sone/core/Core.java index dbda28d..53b6700 100644 --- a/src/main/java/net/pterodactylus/sone/core/Core.java +++ b/src/main/java/net/pterodactylus/sone/core/Core.java @@ -25,6 +25,7 @@ import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.Map.Entry; import java.util.logging.Level; import java.util.logging.Logger; @@ -85,6 +86,9 @@ public class Core implements IdentityListener, UpdateListener { /** The options. */ private final Options options = new Options(); + /** The preferences. */ + private final Preferences preferences = new Preferences(options); + /** The core listener manager. */ private final CoreListenerManager coreListenerManager = new CoreListenerManager(this); @@ -155,6 +159,10 @@ public class Core implements IdentityListener, UpdateListener { /** All known replies. */ private Set knownReplies = new HashSet(); + /** All bookmarked posts. */ + /* synchronize access on itself. */ + private Set bookmarkedPosts = new HashSet(); + /** Trusted identities, sorted by own identities. */ private Map> trustedIdentities = Collections.synchronizedMap(new HashMap>()); @@ -221,18 +229,8 @@ public class Core implements IdentityListener, UpdateListener { * * @return The options of the core */ - public Options getOptions() { - return options; - } - - /** - * Returns whether the “Sone rescue mode” is currently activated. - * - * @return {@code true} if the “Sone rescue mode” is currently activated, - * {@code false} if it is not - */ - public boolean isSoneRescueMode() { - return options.getBooleanOption("SoneRescueMode").get(); + public Preferences getPreferences() { + return preferences; } /** @@ -528,7 +526,8 @@ public class Core implements IdentityListener, UpdateListener { * @return {@code true} if the target Sone is trusted by the origin Sone */ public boolean isSoneTrusted(Sone origin, Sone target) { - return trustedIdentities.containsKey(origin) && trustedIdentities.get(origin.getIdentity()).contains(target); + Validation.begin().isNotNull("Origin", origin).isNotNull("Target", target).check().isInstanceOf("Origin’s OwnIdentity", origin.getIdentity(), OwnIdentity.class).check(); + return trustedIdentities.containsKey(origin.getIdentity()) && trustedIdentities.get(origin.getIdentity()).contains(target.getIdentity()); } /** @@ -536,7 +535,7 @@ public class Core implements IdentityListener, UpdateListener { * * @param postId * The ID of the post to get - * @return The post, or {@code null} if there is no such post + * @return The post with the given ID, or a new post with the given ID */ public Post getPost(String postId) { return getPost(postId, true); @@ -578,6 +577,27 @@ public class Core implements IdentityListener, UpdateListener { } /** + * Returns all posts that have the given Sone as recipient. + * + * @see Post#getRecipient() + * @param recipient + * The recipient of the posts + * @return All posts that have the given Sone as recipient + */ + public Set getDirectedPosts(Sone recipient) { + Validation.begin().isNotNull("Recipient", recipient).check(); + Set directedPosts = new HashSet(); + synchronized (posts) { + for (Post post : posts.values()) { + if (recipient.equals(post.getRecipient())) { + directedPosts.add(post); + } + } + } + return directedPosts; + } + + /** * Returns the reply with the given ID. If there is no reply with the given * ID yet, a new one is created. * @@ -681,6 +701,50 @@ public class Core implements IdentityListener, UpdateListener { return sones; } + /** + * Returns whether the given post is bookmarked. + * + * @param post + * The post to check + * @return {@code true} if the given post is bookmarked, {@code false} + * otherwise + */ + public boolean isBookmarked(Post post) { + return isPostBookmarked(post.getId()); + } + + /** + * Returns whether the post with the given ID is bookmarked. + * + * @param id + * The ID of the post to check + * @return {@code true} if the post with the given ID is bookmarked, + * {@code false} otherwise + */ + public boolean isPostBookmarked(String id) { + synchronized (bookmarkedPosts) { + return bookmarkedPosts.contains(id); + } + } + + /** + * Returns all currently known bookmarked posts. + * + * @return All bookmarked posts + */ + public Set getBookmarkedPosts() { + Set posts = new HashSet(); + synchronized (bookmarkedPosts) { + for (String bookmarkedPostId : bookmarkedPosts) { + Post post = getPost(bookmarkedPostId, false); + if (post != null) { + posts.add(post); + } + } + } + return posts; + } + // // ACTIONS // @@ -767,7 +831,7 @@ public class Core implements IdentityListener, UpdateListener { soneInserters.put(sone, soneInserter); setSoneStatus(sone, SoneStatus.idle); loadSone(sone); - if (!isSoneRescueMode()) { + if (!preferences.isSoneRescueMode()) { soneInserter.start(); } new Thread(new Runnable() { @@ -775,15 +839,14 @@ public class Core implements IdentityListener, UpdateListener { @Override @SuppressWarnings("synthetic-access") public void run() { - if (!isSoneRescueMode()) { - soneDownloader.fetchSone(sone); + if (!preferences.isSoneRescueMode()) { return; } logger.log(Level.INFO, "Trying to restore Sone from Freenet…"); coreListenerManager.fireRescuingSone(sone); lockSone(sone); long edition = sone.getLatestEdition(); - while (!stopped && (edition >= 0) && isSoneRescueMode()) { + while (!stopped && (edition >= 0) && preferences.isSoneRescueMode()) { logger.log(Level.FINE, "Downloading edition " + edition + "…"); soneDownloader.fetchSone(sone, sone.getRequestUri().setKeyType("SSK").setDocName("Sone-" + edition)); --edition; @@ -814,6 +877,9 @@ public class Core implements IdentityListener, UpdateListener { return null; } Sone sone = addLocalSone(ownIdentity); + sone.getOptions().addBooleanOption("AutoFollow", new DefaultOption(false)); + sone.addFriend("nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI"); + saveSone(sone); return sone; } @@ -843,6 +909,11 @@ public class Core implements IdentityListener, UpdateListener { } if (newSone) { coreListenerManager.fireNewSoneFound(sone); + for (Sone localSone : getLocalSones()) { + if (localSone.getOptions().getBooleanOption("AutoFollow").get()) { + localSone.addFriend(sone.getId()); + } + } } } remoteSones.put(identity.getId(), sone); @@ -853,7 +924,7 @@ public class Core implements IdentityListener, UpdateListener { @Override @SuppressWarnings("synthetic-access") public void run() { - soneDownloader.fetchSone(sone); + soneDownloader.fetchSone(sone, sone.getRequestUri()); } }, "Sone Downloader").start(); @@ -893,7 +964,7 @@ public class Core implements IdentityListener, UpdateListener { public void setTrust(Sone origin, Sone target, int trustValue) { Validation.begin().isNotNull("Trust Origin", origin).check().isInstanceOf("Trust Origin", origin.getIdentity(), OwnIdentity.class).isNotNull("Trust Target", target).isLessOrEqual("Trust Value", trustValue, 100).isGreaterOrEqual("Trust Value", trustValue, -100).check(); try { - ((OwnIdentity) origin.getIdentity()).setTrust(target.getIdentity(), trustValue, options.getStringOption("TrustComment").get()); + ((OwnIdentity) origin.getIdentity()).setTrust(target.getIdentity(), trustValue, preferences.getTrustComment()); } catch (WebOfTrustException wote1) { logger.log(Level.WARNING, "Could not set trust for Sone: " + target, wote1); } @@ -925,7 +996,7 @@ public class Core implements IdentityListener, UpdateListener { * The trust target */ public void trustSone(Sone origin, Sone target) { - setTrust(origin, target, options.getIntegerOption("PositiveTrust").get()); + setTrust(origin, target, preferences.getPositiveTrust()); } /** @@ -937,7 +1008,7 @@ public class Core implements IdentityListener, UpdateListener { * The trust target */ public void distrustSone(Sone origin, Sone target) { - setTrust(origin, target, options.getIntegerOption("NegativeTrust").get()); + setTrust(origin, target, preferences.getNegativeTrust()); } /** @@ -960,7 +1031,7 @@ public class Core implements IdentityListener, UpdateListener { */ public void updateSone(Sone sone) { if (hasSone(sone.getId())) { - boolean soneRescueMode = isLocalSone(sone) && isSoneRescueMode(); + boolean soneRescueMode = isLocalSone(sone) && preferences.isSoneRescueMode(); Sone storedSone = getSone(sone.getId()); if (!soneRescueMode && !(sone.getTime() > storedSone.getTime())) { logger.log(Level.FINE, "Downloaded Sone %s is not newer than stored Sone %s.", new Object[] { sone, storedSone }); @@ -996,7 +1067,7 @@ public class Core implements IdentityListener, UpdateListener { } } } - Set storedReplies = sone.getReplies(); + Set storedReplies = storedSone.getReplies(); synchronized (newReplies) { for (Reply reply : sone.getReplies()) { reply.setSone(storedSone); @@ -1102,6 +1173,9 @@ public class Core implements IdentityListener, UpdateListener { return; } + /* initialize options. */ + sone.getOptions().addBooleanOption("AutoFollow", new DefaultOption(false)); + /* load Sone. */ String sonePrefix = "Sone/" + sone.getId(); Long soneTime = configuration.getLongValue(sonePrefix + "/Time").getValue(null); @@ -1201,6 +1275,9 @@ public class Core implements IdentityListener, UpdateListener { friends.add(friendId); } + /* load options. */ + sone.getOptions().getBooleanOption("AutoFollow").set(configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").getValue(null)); + /* if we’re still here, Sone was loaded successfully. */ synchronized (sone) { sone.setTime(soneTime); @@ -1316,6 +1393,9 @@ public class Core implements IdentityListener, UpdateListener { } configuration.getStringValue(sonePrefix + "/Friends/" + friendCounter + "/ID").setValue(null); + /* save options. */ + configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").setValue(sone.getOptions().getBooleanOption("AutoFollow").getReal()); + configuration.save(); logger.log(Level.INFO, "Sone %s saved.", sone); } catch (ConfigurationException ce1) { @@ -1396,7 +1476,8 @@ public class Core implements IdentityListener, UpdateListener { posts.put(post.getId(), post); } synchronized (newPosts) { - knownPosts.add(post.getId()); + newPosts.add(post.getId()); + coreListenerManager.fireNewPostFound(post); } sone.addPost(post); saveSone(sone); @@ -1418,6 +1499,11 @@ public class Core implements IdentityListener, UpdateListener { synchronized (posts) { posts.remove(post.getId()); } + coreListenerManager.firePostRemoved(post); + synchronized (newPosts) { + markPostKnown(post); + knownPosts.remove(post.getId()); + } saveSone(post.getSone()); } @@ -1439,6 +1525,50 @@ public class Core implements IdentityListener, UpdateListener { } /** + * Bookmarks the given post. + * + * @param post + * The post to bookmark + */ + public void bookmark(Post post) { + bookmarkPost(post.getId()); + } + + /** + * Bookmarks the post with the given ID. + * + * @param id + * The ID of the post to bookmark + */ + public void bookmarkPost(String id) { + synchronized (bookmarkedPosts) { + bookmarkedPosts.add(id); + } + } + + /** + * Removes the given post from the bookmarks. + * + * @param post + * The post to unbookmark + */ + public void unbookmark(Post post) { + unbookmarkPost(post.getId()); + } + + /** + * Removes the post with the given ID from the bookmarks. + * + * @param id + * The ID of the post to unbookmark + */ + public void unbookmarkPost(String id) { + synchronized (bookmarkedPosts) { + bookmarkedPosts.remove(id); + } + } + + /** * Creates a new reply. * * @param sone @@ -1476,7 +1606,8 @@ public class Core implements IdentityListener, UpdateListener { replies.put(reply.getId(), reply); } synchronized (newReplies) { - knownReplies.add(reply.getId()); + newReplies.add(reply.getId()); + coreListenerManager.fireNewReplyFound(reply); } sone.addReply(reply); saveSone(sone); @@ -1498,6 +1629,10 @@ public class Core implements IdentityListener, UpdateListener { synchronized (replies) { replies.remove(reply.getId()); } + synchronized (newReplies) { + markReplyKnown(reply); + knownReplies.remove(reply.getId()); + } sone.removeReply(reply); saveSone(sone); } @@ -1560,6 +1695,7 @@ public class Core implements IdentityListener, UpdateListener { try { configuration.getIntValue("Option/ConfigurationVersion").setValue(0); configuration.getIntValue("Option/InsertionDelay").setValue(options.getIntegerOption("InsertionDelay").getReal()); + configuration.getIntValue("Option/PostsPerPage").setValue(options.getIntegerOption("PostsPerPage").getReal()); configuration.getIntValue("Option/PositiveTrust").setValue(options.getIntegerOption("PositiveTrust").getReal()); configuration.getIntValue("Option/NegativeTrust").setValue(options.getIntegerOption("NegativeTrust").getReal()); configuration.getStringValue("Option/TrustComment").setValue(options.getStringOption("TrustComment").getReal()); @@ -1594,6 +1730,15 @@ public class Core implements IdentityListener, UpdateListener { configuration.getStringValue("KnownReplies/" + replyCounter + "/ID").setValue(null); } + /* save bookmarked posts. */ + int bookmarkedPostCounter = 0; + synchronized (bookmarkedPosts) { + for (String bookmarkedPostId : bookmarkedPosts) { + configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").setValue(bookmarkedPostId); + } + } + configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").setValue(null); + /* now save it. */ configuration.save(); @@ -1624,8 +1769,9 @@ public class Core implements IdentityListener, UpdateListener { } })); + options.addIntegerOption("PostsPerPage", new DefaultOption(10)); options.addIntegerOption("PositiveTrust", new DefaultOption(75)); - options.addIntegerOption("NegativeTrust", new DefaultOption(-100)); + options.addIntegerOption("NegativeTrust", new DefaultOption(-25)); options.addStringOption("TrustComment", new DefaultOption("Set from Sone Web Interface")); options.addBooleanOption("SoneRescueMode", new DefaultOption(false)); options.addBooleanOption("ClearOnNextRestart", new DefaultOption(false)); @@ -1643,6 +1789,7 @@ public class Core implements IdentityListener, UpdateListener { } options.getIntegerOption("InsertionDelay").set(configuration.getIntValue("Option/InsertionDelay").getValue(null)); + options.getIntegerOption("PostsPerPage").set(configuration.getIntValue("Option/PostsPerPage").getValue(null)); options.getIntegerOption("PositiveTrust").set(configuration.getIntValue("Option/PositiveTrust").getValue(null)); options.getIntegerOption("NegativeTrust").set(configuration.getIntValue("Option/NegativeTrust").getValue(null)); options.getStringOption("TrustComment").set(configuration.getStringValue("Option/TrustComment").getValue(null)); @@ -1684,6 +1831,18 @@ public class Core implements IdentityListener, UpdateListener { } } + /* load bookmarked posts. */ + int bookmarkedPostCounter = 0; + while (true) { + String bookmarkedPostId = configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").getValue(null); + if (bookmarkedPostId == null) { + break; + } + synchronized (bookmarkedPosts) { + bookmarkedPosts.add(bookmarkedPostId); + } + } + } /** @@ -1750,6 +1909,8 @@ public class Core implements IdentityListener, UpdateListener { public void run() { Sone sone = getRemoteSone(identity.getId()); sone.setIdentity(identity); + sone.setLatestEdition(Numbers.safeParseLong(identity.getProperty("Sone.LatestEdition"), sone.getLatestEdition())); + soneDownloader.addSone(sone); soneDownloader.fetchSone(sone); } }).start(); @@ -1761,6 +1922,48 @@ public class Core implements IdentityListener, UpdateListener { @Override public void identityRemoved(OwnIdentity ownIdentity, Identity identity) { trustedIdentities.get(ownIdentity).remove(identity); + boolean foundIdentity = false; + for (Entry> trustedIdentity : trustedIdentities.entrySet()) { + if (trustedIdentity.getKey().equals(ownIdentity)) { + continue; + } + if (trustedIdentity.getValue().contains(identity)) { + foundIdentity = true; + } + } + if (foundIdentity) { + /* some local identity still trusts this identity, don’t remove. */ + return; + } + Sone sone = getSone(identity.getId(), false); + if (sone == null) { + /* TODO - we don’t have the Sone anymore. should this happen? */ + return; + } + synchronized (posts) { + synchronized (newPosts) { + for (Post post : sone.getPosts()) { + posts.remove(post.getId()); + newPosts.remove(post.getId()); + coreListenerManager.firePostRemoved(post); + } + } + } + synchronized (replies) { + synchronized (newReplies) { + for (Reply reply : sone.getReplies()) { + replies.remove(reply.getId()); + newReplies.remove(reply.getId()); + coreListenerManager.fireReplyRemoved(reply); + } + } + } + synchronized (remoteSones) { + remoteSones.remove(identity.getId()); + } + synchronized (newSones) { + newSones.remove(identity.getId()); + } } // @@ -1771,8 +1974,216 @@ public class Core implements IdentityListener, UpdateListener { * {@inheritDoc} */ @Override - public void updateFound(Version version, long releaseTime) { - coreListenerManager.fireUpdateFound(version, releaseTime); + public void updateFound(Version version, long releaseTime, long latestEdition) { + coreListenerManager.fireUpdateFound(version, releaseTime, latestEdition); + } + + /** + * Convenience interface for external classes that want to access the core’s + * configuration. + * + * @author David ‘Bombe’ Roden + */ + public static class Preferences { + + /** The wrapped options. */ + private final Options options; + + /** + * Creates a new preferences object wrapped around the given options. + * + * @param options + * The options to wrap + */ + public Preferences(Options options) { + this.options = options; + } + + /** + * Returns the insertion delay. + * + * @return The insertion delay + */ + public int getInsertionDelay() { + return options.getIntegerOption("InsertionDelay").get(); + } + + /** + * Sets the insertion delay + * + * @param insertionDelay + * The new insertion delay, or {@code null} to restore it to + * the default value + * @return This preferences + */ + public Preferences setInsertionDelay(Integer insertionDelay) { + options.getIntegerOption("InsertionDelay").set(insertionDelay); + return this; + } + + /** + * Returns the number of posts to show per page. + * + * @return The number of posts to show per page + */ + public int getPostsPerPage() { + return options.getIntegerOption("PostsPerPage").get(); + } + + /** + * Sets the number of posts to show per page. + * + * @param postsPerPage + * The number of posts to show per page + * @return This preferences object + */ + public Preferences setPostsPerPage(Integer postsPerPage) { + options.getIntegerOption("PostsPerPage").set(postsPerPage); + return this; + } + + /** + * Returns the positive trust. + * + * @return The positive trust + */ + public int getPositiveTrust() { + return options.getIntegerOption("PositiveTrust").get(); + } + + /** + * Sets the positive trust. + * + * @param positiveTrust + * The new positive trust, or {@code null} to restore it to + * the default vlaue + * @return This preferences + */ + public Preferences setPositiveTrust(Integer positiveTrust) { + options.getIntegerOption("PositiveTrust").set(positiveTrust); + return this; + } + + /** + * Returns the negative trust. + * + * @return The negative trust + */ + public int getNegativeTrust() { + return options.getIntegerOption("NegativeTrust").get(); + } + + /** + * Sets the negative trust. + * + * @param negativeTrust + * The negative trust, or {@code null} to restore it to the + * default value + * @return The preferences + */ + public Preferences setNegativeTrust(Integer negativeTrust) { + options.getIntegerOption("NegativeTrust").set(negativeTrust); + return this; + } + + /** + * Returns the trust comment. This is the comment that is set in the web + * of trust when a trust value is assigned to an identity. + * + * @return The trust comment + */ + public String getTrustComment() { + return options.getStringOption("TrustComment").get(); + } + + /** + * Sets the trust comment. + * + * @param trustComment + * The trust comment, or {@code null} to restore it to the + * default value + * @return This preferences + */ + public Preferences setTrustComment(String trustComment) { + options.getStringOption("TrustComment").set(trustComment); + return this; + } + + /** + * Returns whether the rescue mode is active. + * + * @return {@code true} if the rescue mode is active, {@code false} + * otherwise + */ + public boolean isSoneRescueMode() { + return options.getBooleanOption("SoneRescueMode").get(); + } + + /** + * Sets whether the rescue mode is active. + * + * @param soneRescueMode + * {@code true} if the rescue mode is active, {@code false} + * otherwise + * @return This preferences + */ + public Preferences setSoneRescueMode(Boolean soneRescueMode) { + options.getBooleanOption("SoneRescueMode").set(soneRescueMode); + return this; + } + + /** + * Returns whether Sone should clear its settings on the next restart. + * In order to be effective, {@link #isReallyClearOnNextRestart()} needs + * to return {@code true} as well! + * + * @return {@code true} if Sone should clear its settings on the next + * restart, {@code false} otherwise + */ + public boolean isClearOnNextRestart() { + return options.getBooleanOption("ClearOnNextRestart").get(); + } + + /** + * Sets whether Sone will clear its settings on the next restart. + * + * @param clearOnNextRestart + * {@code true} if Sone should clear its settings on the next + * restart, {@code false} otherwise + * @return This preferences + */ + public Preferences setClearOnNextRestart(Boolean clearOnNextRestart) { + options.getBooleanOption("ClearOnNextRestart").set(clearOnNextRestart); + return this; + } + + /** + * Returns whether Sone should really clear its settings on next + * restart. This is a confirmation option that needs to be set in + * addition to {@link #isClearOnNextRestart()} in order to clear Sone’s + * settings on the next restart. + * + * @return {@code true} if Sone should really clear its settings on the + * next restart, {@code false} otherwise + */ + public boolean isReallyClearOnNextRestart() { + return options.getBooleanOption("ReallyClearOnNextRestart").get(); + } + + /** + * Sets whether Sone should really clear its settings on the next + * restart. + * + * @param reallyClearOnNextRestart + * {@code true} if Sone should really clear its settings on + * the next restart, {@code false} otherwise + * @return This preferences + */ + public Preferences setReallyClearOnNextRestart(Boolean reallyClearOnNextRestart) { + options.getBooleanOption("ReallyClearOnNextRestart").set(reallyClearOnNextRestart); + return this; + } + } }