X-Git-Url: https://git.pterodactylus.net/?p=WoTNS.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fwotns%2Ffreenet%2Fwot%2FIdentityManager.java;h=5a5310605244ad20efbb33c17137f53fdc6473e7;hp=e9107fefa196d1a67d72ff6cc5dc35a9e044aa06;hb=9251a40d3196f48d8c72b604ee8944bf391d26b0;hpb=622c4a4d3ebed447d5708a41cf3e1e82e18fa29b diff --git a/src/main/java/net/pterodactylus/wotns/freenet/wot/IdentityManager.java b/src/main/java/net/pterodactylus/wotns/freenet/wot/IdentityManager.java index e9107fe..5a53106 100644 --- a/src/main/java/net/pterodactylus/wotns/freenet/wot/IdentityManager.java +++ b/src/main/java/net/pterodactylus/wotns/freenet/wot/IdentityManager.java @@ -17,6 +17,7 @@ package net.pterodactylus.wotns.freenet.wot; +import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; @@ -26,7 +27,6 @@ import java.util.Map.Entry; import java.util.logging.Level; import java.util.logging.Logger; -import net.pterodactylus.util.collection.SetBuilder; import net.pterodactylus.util.logging.Logging; import net.pterodactylus.util.service.AbstractService; import net.pterodactylus.wotns.freenet.plugin.PluginException; @@ -66,7 +66,7 @@ public class IdentityManager extends AbstractService { private Map currentOwnIdentities = new HashMap(); /** The currently trusted identities. */ - private Map> currentTrustedIdentities = new HashMap>(); + private Map> currentTrustedIdentities = new HashMap>(); /** * Creates a new identity manager. @@ -171,15 +171,34 @@ public class IdentityManager extends AbstractService { } } + /** + * Returns all identities that are trusted by the given own identity. In + * addition to all non-own identities the given own identity is also + * returned. + * + * @param ownIdentity + * The own identity to get the trusted identities for + * @return The identities trusted by the given own identity + */ public Set getTrustedIdentities(OwnIdentity ownIdentity) { - SetBuilder identities = new SetBuilder(); - if ((context == null) || ownIdentity.getContexts().contains(context)) { - identities.add(ownIdentity); + Set identities = new HashSet(); + for (OwnIdentity additionalOwnIdentity : getAllOwnIdentities()) { + if ((context == null) || additionalOwnIdentity.getContexts().contains(context)) { + identities.add(additionalOwnIdentity); + } } - synchronized (syncObject) { - identities.addAll(currentTrustedIdentities.get(ownIdentity)); + try { + Set trustedIdentities = webOfTrustConnector.loadTrustedIdentities(ownIdentity, context); + Map newTrustedIdentities = new HashMap(); + for (Identity trustedIdentity : trustedIdentities) { + newTrustedIdentities.put(trustedIdentity.getId(), trustedIdentity); + } + checkTrustedIdentities(ownIdentity, newTrustedIdentities); + identities.addAll(trustedIdentities); + } catch (WebOfTrustException wote1) { + logger.log(Level.WARNING, String.format("Could not load all trusted identities for %s.", ownIdentity), wote1); } - return identities.get(); + return identities; } // @@ -191,10 +210,8 @@ public class IdentityManager extends AbstractService { */ @Override protected void serviceRun() { - Map> oldIdentities = Collections.emptyMap(); while (!shouldStop()) { Map> currentIdentities = new HashMap>(); - @SuppressWarnings("hiding") Map currentOwnIdentities = new HashMap(); Set ownIdentities = null; @@ -216,6 +233,20 @@ public class IdentityManager extends AbstractService { for (Identity identity : trustedIdentities) { identities.put(identity.getId(), identity); } + + /* + * add own identities, too, as long as the WoT doesn’t do + * that. + */ + for (OwnIdentity additionalOwnIdentity : ownIdentities) { + if (additionalOwnIdentity == ownIdentity) { + continue; + } + if ((context != null) && !additionalOwnIdentity.hasContext(context)) { + continue; + } + identities.put(additionalOwnIdentity.getId(), additionalOwnIdentity); + } } identitiesLoaded = true; } catch (WebOfTrustException wote1) { @@ -229,75 +260,7 @@ public class IdentityManager extends AbstractService { /* now check for changes in remote identities. */ for (OwnIdentity ownIdentity : currentOwnIdentities.values()) { - - /* find new identities. */ - for (Identity currentIdentity : currentIdentities.get(ownIdentity).values()) { - if (!oldIdentities.containsKey(ownIdentity) || !oldIdentities.get(ownIdentity).containsKey(currentIdentity.getId())) { - identityListenerManager.fireIdentityAdded(ownIdentity, currentIdentity); - } - } - - /* find removed identities. */ - if (oldIdentities.containsKey(ownIdentity)) { - for (Identity oldIdentity : oldIdentities.get(ownIdentity).values()) { - if (!currentIdentities.get(ownIdentity).containsKey(oldIdentity.getId())) { - identityListenerManager.fireIdentityRemoved(ownIdentity, oldIdentity); - } - } - - /* check for changes in the contexts. */ - for (Identity oldIdentity : oldIdentities.get(ownIdentity).values()) { - if (!currentIdentities.get(ownIdentity).containsKey(oldIdentity.getId())) { - continue; - } - Identity newIdentity = currentIdentities.get(ownIdentity).get(oldIdentity.getId()); - Set oldContexts = oldIdentity.getContexts(); - Set newContexts = newIdentity.getContexts(); - if (oldContexts.size() != newContexts.size()) { - identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); - continue; - } - for (String oldContext : oldContexts) { - if (!newContexts.contains(oldContext)) { - identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); - break; - } - } - } - - /* check for changes in the properties. */ - for (Identity oldIdentity : oldIdentities.get(ownIdentity).values()) { - if (!currentIdentities.get(ownIdentity).containsKey(oldIdentity.getId())) { - continue; - } - Identity newIdentity = currentIdentities.get(ownIdentity).get(oldIdentity.getId()); - Map oldProperties = oldIdentity.getProperties(); - Map newProperties = newIdentity.getProperties(); - if (oldProperties.size() != newProperties.size()) { - identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); - continue; - } - for (Entry oldProperty : oldProperties.entrySet()) { - if (!newProperties.containsKey(oldProperty.getKey()) || !newProperties.get(oldProperty.getKey()).equals(oldProperty.getValue())) { - identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); - break; - } - } - } - } - } - - /* remember the current set of identities. */ - oldIdentities = currentIdentities; - synchronized (syncObject) { - currentTrustedIdentities.clear(); - for (Entry> entry : currentIdentities.entrySet()) { - Set identities = new HashSet(); - currentTrustedIdentities.put(entry.getKey(), identities); - for (Identity identity : entry.getValue().values()) { - identities.add(identity); - } - } + checkTrustedIdentities(ownIdentity, currentIdentities.get(ownIdentity)); } } @@ -324,6 +287,7 @@ public class IdentityManager extends AbstractService { for (OwnIdentity oldOwnIdentity : currentOwnIdentities.values()) { if (!newOwnIdentities.containsKey(oldOwnIdentity.getId())) { identityListenerManager.fireOwnIdentityRemoved(oldOwnIdentity); + currentTrustedIdentities.remove(oldOwnIdentity); } } @@ -339,4 +303,80 @@ public class IdentityManager extends AbstractService { } } + /** + * Checks the given identities for changes since the last check. + * + * @param ownIdentity + * The own identity trusting the given identities + * @param trustedIdentities + * The trusted identities + */ + private void checkTrustedIdentities(OwnIdentity ownIdentity, Map trustedIdentities) { + + Map currentTrustedIdentities = new HashMap(); + synchronized (syncObject) { + if (this.currentTrustedIdentities.containsKey(ownIdentity)) { + for (Identity identity : this.currentTrustedIdentities.get(ownIdentity)) { + currentTrustedIdentities.put(identity.getId(), identity); + } + } + } + + /* find new identities. */ + for (Identity currentIdentity : trustedIdentities.values()) { + if (!currentTrustedIdentities.containsKey(currentIdentity.getId())) { + identityListenerManager.fireIdentityAdded(ownIdentity, currentIdentity); + } + } + + /* find removed identities. */ + for (Identity oldIdentity : currentTrustedIdentities.values()) { + if (!trustedIdentities.containsKey(oldIdentity.getId())) { + identityListenerManager.fireIdentityRemoved(ownIdentity, oldIdentity); + } + } + + /* check for changes in the contexts. */ + for (Identity oldIdentity : currentTrustedIdentities.values()) { + if (!trustedIdentities.containsKey(oldIdentity.getId())) { + continue; + } + Identity newIdentity = trustedIdentities.get(oldIdentity.getId()); + Set oldContexts = oldIdentity.getContexts(); + Set newContexts = newIdentity.getContexts(); + if (oldContexts.size() != newContexts.size()) { + identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); + continue; + } + boolean changed = false; + for (String oldContext : oldContexts) { + if (!newContexts.contains(oldContext)) { + identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); + changed = true; + break; + } + } + if (changed) { + continue; + } + Map oldProperties = oldIdentity.getProperties(); + Map newProperties = newIdentity.getProperties(); + if (oldProperties.size() != newProperties.size()) { + identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); + continue; + } + for (Entry oldProperty : oldProperties.entrySet()) { + if (!newProperties.containsKey(oldProperty.getKey()) || !newProperties.get(oldProperty.getKey()).equals(oldProperty.getValue())) { + identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity); + break; + } + } + } + + synchronized (syncObject) { + this.currentTrustedIdentities.put(ownIdentity, trustedIdentities.values()); + } + + } + }