Use the identity loader for loading identities.

[Sone.git] / src / main / java / net / pterodactylus / sone / freenet / wot / IdentityManager.java

diff --git a/src/main/java/net/pterodactylus/sone/freenet/wot/IdentityManager.java b/src/main/java/net/pterodactylus/sone/freenet/wot/IdentityManager.java
index 2933483..9817038 100644 (file)
--- a/src/main/java/net/pterodactylus/sone/freenet/wot/IdentityManager.java
+++ b/src/main/java/net/pterodactylus/sone/freenet/wot/IdentityManager.java
@@ -17,9 +17,9 @@
 
 package net.pterodactylus.sone.freenet.wot;
 
+import static com.google.common.base.Optional.fromNullable;
 import static com.google.common.collect.HashMultimap.create;
 
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.logging.Level;
@@ -54,24 +54,17 @@ import com.google.inject.name.Named;
  */
 public class IdentityManager extends AbstractService {
 
-       /** Object used for synchronization. */
-       @SuppressWarnings("hiding")
-       private final Object syncObject = new Object() {
-               /* inner class for better lock names. */
-       };
-
        /** The logger. */
        private static final Logger logger = Logging.getLogger(IdentityManager.class);
 
        /** The event bus. */
        private final EventBus eventBus;
 
+       private final IdentityLoader identityLoader;
+
        /** The Web of Trust connector. */
        private final WebOfTrustConnector webOfTrustConnector;
 
-       /** The context to filter for. */
-       private final String context;
-
        /** The currently known own identities. */
        /* synchronize access on syncObject. */
        private final Set<OwnIdentity> currentOwnIdentities = Sets.newHashSet();
@@ -91,7 +84,7 @@ public class IdentityManager extends AbstractService {
                super("Sone Identity Manager", false);
                this.eventBus = eventBus;
                this.webOfTrustConnector = webOfTrustConnector;
-               this.context = context;
+               this.identityLoader = new IdentityLoader(webOfTrustConnector, fromNullable(context));
        }
 
        //
@@ -121,7 +114,7 @@ public class IdentityManager extends AbstractService {
         * @return All own identities
         */
        public Set<OwnIdentity> getAllOwnIdentities() {
-               synchronized (syncObject) {
+               synchronized (currentOwnIdentities) {
                        return new HashSet<OwnIdentity>(currentOwnIdentities);
                }
        }
@@ -136,15 +129,14 @@ public class IdentityManager extends AbstractService {
 
                while (!shouldStop()) {
                        try {
-                               Collection<OwnIdentity> currentOwnIdentities = webOfTrustConnector.loadAllOwnIdentities();
-                               Multimap<OwnIdentity, Identity> currentIdentities = loadTrustedIdentitiesForOwnIdentities(currentOwnIdentities);
+                               Multimap<OwnIdentity, Identity> currentIdentities = identityLoader.loadIdentities();
 
-                               detectChangesInIdentities(currentOwnIdentities, currentIdentities, oldIdentities);
+                               detectChangesInIdentities(currentIdentities, oldIdentities);
                                oldIdentities = currentIdentities;
 
-                               synchronized (syncObject) {
-                                       this.currentOwnIdentities.clear();
-                                       this.currentOwnIdentities.addAll(currentOwnIdentities);
+                               synchronized (currentOwnIdentities) {
+                                       currentOwnIdentities.clear();
+                                       currentOwnIdentities.addAll(currentIdentities.keySet());
                                }
                        } catch (WebOfTrustException wote1) {
                                logger.log(Level.WARNING, "WoT has disappeared!", wote1);
@@ -155,12 +147,12 @@ public class IdentityManager extends AbstractService {
                }
        }
 
-       private void detectChangesInIdentities(Collection<OwnIdentity> currentOwnIdentities, Multimap<OwnIdentity, Identity> newIdentities, Multimap<OwnIdentity, Identity> oldIdentities) {
+       private void detectChangesInIdentities(Multimap<OwnIdentity, Identity> newIdentities, Multimap<OwnIdentity, Identity> oldIdentities) {
                IdentityChangeDetector identityChangeDetector = new IdentityChangeDetector(getAllOwnIdentities());
                identityChangeDetector.onNewIdentity(addNewOwnIdentityAndItsTrustedIdentities(newIdentities));
                identityChangeDetector.onRemovedIdentity(removeOwnIdentityAndItsTrustedIdentities(oldIdentities));
                identityChangeDetector.onUnchangedIdentity(detectChangesInTrustedIdentities(newIdentities, oldIdentities));
-               identityChangeDetector.detectChanges(currentOwnIdentities);
+               identityChangeDetector.detectChanges(newIdentities.keySet());
        }
 
        private IdentityProcessor detectChangesInTrustedIdentities(Multimap<OwnIdentity, Identity> newIdentities, Multimap<OwnIdentity, Identity> oldIdentities) {
@@ -191,23 +183,6 @@ public class IdentityManager extends AbstractService {
                };
        }
 
-       private Multimap<OwnIdentity, Identity> loadTrustedIdentitiesForOwnIdentities(Collection<OwnIdentity> ownIdentities) throws PluginException {
-               Multimap<OwnIdentity, Identity> currentIdentities = create();
-
-               for (OwnIdentity ownIdentity : ownIdentities) {
-                       if ((context != null) && !ownIdentity.hasContext(context)) {
-                               continue;
-                       }
-
-                       logger.finer(String.format("Getting trusted identities for %s...", ownIdentity.getId()));
-                       Set<Identity> trustedIdentities = webOfTrustConnector.loadTrustedIdentities(ownIdentity, context);
-                       logger.finest(String.format("Got %d trusted identities.", trustedIdentities.size()));
-                       currentIdentities.putAll(ownIdentity, trustedIdentities);
-               }
-
-               return currentIdentities;
-       }
-
        private class DefaultIdentityProcessor implements IdentityProcessor {
 
                private final Multimap<OwnIdentity, Identity> oldIdentities;