src/main/java/net/pterodactylus/wotns/freenet/wot/IdentityManager.java

   1 /*
   2  * Sone - IdentityManager.java - Copyright © 2010 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.wotns.freenet.wot;
  19
  20 import java.util.Collection;
  21 import java.util.Collections;
  22 import java.util.HashMap;
  23 import java.util.HashSet;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.Map.Entry;
  27 import java.util.logging.Level;
  28 import java.util.logging.Logger;
  29
  30 import net.pterodactylus.util.logging.Logging;
  31 import net.pterodactylus.util.service.AbstractService;
  32 import net.pterodactylus.wotns.freenet.plugin.PluginException;
  33
  34 /**
  35  * The identity manager takes care of loading and storing identities, their
  36  * contexts, and properties. It does so in a way that does not expose errors via
  37  * exceptions but it only logs them and tries to return sensible defaults.
  38  * <p>
  39  * It is also responsible for polling identities from the Web of Trust plugin
  40  * and notifying registered {@link IdentityListener}s when {@link Identity}s and
  41  * {@link OwnIdentity}s are discovered or disappearing.
  42  *
  43  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  44  */
  45 public class IdentityManager extends AbstractService {
  46
  47         /** Object used for synchronization. */
  48         private final Object syncObject = new Object() {
  49                 /* inner class for better lock names. */
  50         };
  51
  52         /** The logger. */
  53         private static final Logger logger = Logging.getLogger(IdentityManager.class);
  54
  55         /** The event manager. */
  56         private final IdentityListenerManager identityListenerManager = new IdentityListenerManager();
  57
  58         /** The Web of Trust connector. */
  59         private final WebOfTrustConnector webOfTrustConnector;
  60
  61         /** The context to filter for. */
  62         private volatile String context;
  63
  64         /** The currently known own identities. */
  65         /* synchronize access on syncObject. */
  66         private Map<String, OwnIdentity> currentOwnIdentities = new HashMap<String, OwnIdentity>();
  67
  68         /** The currently trusted identities. */
  69         private Map<OwnIdentity, Collection<Identity>> currentTrustedIdentities = new HashMap<OwnIdentity, Collection<Identity>>();
  70
  71         /**
  72          * Creates a new identity manager.
  73          *
  74          * @param webOfTrustConnector
  75          *            The Web of Trust connector
  76          */
  77         public IdentityManager(WebOfTrustConnector webOfTrustConnector) {
  78                 super("Sone Identity Manager", false);
  79                 this.webOfTrustConnector = webOfTrustConnector;
  80         }
  81
  82         //
  83         // LISTENER MANAGEMENT
  84         //
  85
  86         /**
  87          * Adds a listener for identity events.
  88          *
  89          * @param identityListener
  90          *            The listener to add
  91          */
  92         public void addIdentityListener(IdentityListener identityListener) {
  93                 identityListenerManager.addListener(identityListener);
  94         }
  95
  96         /**
  97          * Removes a listener for identity events.
  98          *
  99          * @param identityListener
 100          *            The listener to remove
 101          */
 102         public void removeIdentityListener(IdentityListener identityListener) {
 103                 identityListenerManager.removeListener(identityListener);
 104         }
 105
 106         //
 107         // ACCESSORS
 108         //
 109
 110         /**
 111          * Sets the context to filter own identities and trusted identities for.
 112          *
 113          * @param context
 114          *            The context to filter for, or {@code null} to not filter
 115          */
 116         public void setContext(String context) {
 117                 this.context = context;
 118         }
 119
 120         /**
 121          * Returns whether the Web of Trust plugin could be reached during the last
 122          * try.
 123          *
 124          * @return {@code true} if the Web of Trust plugin is connected, {@code
 125          *         false} otherwise
 126          */
 127         public boolean isConnected() {
 128                 try {
 129                         webOfTrustConnector.ping();
 130                         return true;
 131                 } catch (PluginException pe1) {
 132                         /* not connected, ignore. */
 133                         return false;
 134                 }
 135         }
 136
 137         /**
 138          * Returns the own identity with the given ID.
 139          *
 140          * @param id
 141          *            The ID of the own identity
 142          * @return The own identity, or {@code null} if there is no such identity
 143          */
 144         public OwnIdentity getOwnIdentity(String id) {
 145                 Set<OwnIdentity> allOwnIdentities = getAllOwnIdentities();
 146                 for (OwnIdentity ownIdentity : allOwnIdentities) {
 147                         if (ownIdentity.getId().equals(id)) {
 148                                 return ownIdentity;
 149                         }
 150                 }
 151                 return null;
 152         }
 153
 154         /**
 155          * Returns all own identities.
 156          *
 157          * @return All own identities
 158          */
 159         public Set<OwnIdentity> getAllOwnIdentities() {
 160                 try {
 161                         Set<OwnIdentity> ownIdentities = webOfTrustConnector.loadAllOwnIdentities();
 162                         Map<String, OwnIdentity> newOwnIdentities = new HashMap<String, OwnIdentity>();
 163                         for (OwnIdentity ownIdentity : ownIdentities) {
 164                                 newOwnIdentities.put(ownIdentity.getId(), ownIdentity);
 165                         }
 166                         checkOwnIdentities(newOwnIdentities);
 167                         return ownIdentities;
 168                 } catch (WebOfTrustException wote1) {
 169                         logger.log(Level.WARNING, "Could not load all own identities!", wote1);
 170                         return Collections.emptySet();
 171                 }
 172         }
 173
 174         /**
 175          * Returns all identities that are trusted by the given own identity. In
 176          * addition to all non-own identities the given own identity is also
 177          * returned.
 178          *
 179          * @param ownIdentity
 180          *            The own identity to get the trusted identities for
 181          * @return The identities trusted by the given own identity
 182          */
 183         public Set<Identity> getTrustedIdentities(OwnIdentity ownIdentity) {
 184                 Set<Identity> identities = new HashSet<Identity>();
 185                 for (OwnIdentity additionalOwnIdentity : getAllOwnIdentities()) {
 186                         if ((context == null) || additionalOwnIdentity.getContexts().contains(context)) {
 187                                 identities.add(additionalOwnIdentity);
 188                         }
 189                 }
 190                 try {
 191                         Set<Identity> trustedIdentities = webOfTrustConnector.loadTrustedIdentities(ownIdentity, context);
 192                         Map<String, Identity> newTrustedIdentities = new HashMap<String, Identity>();
 193                         for (Identity trustedIdentity : trustedIdentities) {
 194                                 newTrustedIdentities.put(trustedIdentity.getId(), trustedIdentity);
 195                         }
 196                         checkTrustedIdentities(ownIdentity, newTrustedIdentities);
 197                         identities.addAll(trustedIdentities);
 198                 } catch (WebOfTrustException wote1) {
 199                         logger.log(Level.WARNING, String.format("Could not load all trusted identities for %s.", ownIdentity), wote1);
 200                 }
 201                 return identities;
 202         }
 203
 204         //
 205         // SERVICE METHODS
 206         //
 207
 208         /**
 209          * {@inheritDoc}
 210          */
 211         @Override
 212         protected void serviceRun() {
 213                 while (!shouldStop()) {
 214                         Map<OwnIdentity, Map<String, Identity>> currentIdentities = new HashMap<OwnIdentity, Map<String, Identity>>();
 215                         @SuppressWarnings("hiding")
 216                         Map<String, OwnIdentity> currentOwnIdentities = new HashMap<String, OwnIdentity>();
 217
 218                         Set<OwnIdentity> ownIdentities = null;
 219                         boolean identitiesLoaded = false;
 220                         try {
 221                                 /* get all identities with the wanted context from WoT. */
 222                                 ownIdentities = webOfTrustConnector.loadAllOwnIdentities();
 223
 224                                 /* load trusted identities. */
 225                                 for (OwnIdentity ownIdentity : ownIdentities) {
 226                                         if ((context != null) && !ownIdentity.hasContext(context)) {
 227                                                 continue;
 228                                         }
 229                                         currentOwnIdentities.put(ownIdentity.getId(), ownIdentity);
 230
 231                                         Set<Identity> trustedIdentities = webOfTrustConnector.loadTrustedIdentities(ownIdentity, context);
 232                                         Map<String, Identity> identities = new HashMap<String, Identity>();
 233                                         currentIdentities.put(ownIdentity, identities);
 234                                         for (Identity identity : trustedIdentities) {
 235                                                 identities.put(identity.getId(), identity);
 236                                         }
 237
 238                                         /*
 239                                          * add own identities, too, as long as the WoT doesn’t do
 240                                          * that.
 241                                          */
 242                                         for (OwnIdentity additionalOwnIdentity : ownIdentities) {
 243                                                 if (additionalOwnIdentity == ownIdentity) {
 244                                                         continue;
 245                                                 }
 246                                                 if ((context != null) && !additionalOwnIdentity.hasContext(context)) {
 247                                                         continue;
 248                                                 }
 249                                                 identities.put(additionalOwnIdentity.getId(), additionalOwnIdentity);
 250                                         }
 251                                 }
 252                                 identitiesLoaded = true;
 253                         } catch (WebOfTrustException wote1) {
 254                                 logger.log(Level.WARNING, "WoT has disappeared!", wote1);
 255                         }
 256
 257                         if (identitiesLoaded) {
 258
 259                                 /* check for changes. */
 260                                 checkOwnIdentities(currentOwnIdentities);
 261
 262                                 /* now check for changes in remote identities. */
 263                                 for (OwnIdentity ownIdentity : currentOwnIdentities.values()) {
 264                                         checkTrustedIdentities(ownIdentity, currentIdentities.get(ownIdentity));
 265                                 }
 266                         }
 267
 268                         /* wait a minute before checking again. */
 269                         sleep(60 * 1000);
 270                 }
 271         }
 272
 273         //
 274         // PRIVATE METHODS
 275         //
 276
 277         /**
 278          * Checks the given new list of own identities for added or removed own
 279          * identities, as compared to {@link #currentOwnIdentities}.
 280          *
 281          * @param newOwnIdentities
 282          *            The new own identities
 283          */
 284         private void checkOwnIdentities(Map<String, OwnIdentity> newOwnIdentities) {
 285                 synchronized (syncObject) {
 286
 287                         /* find removed own identities: */
 288                         for (OwnIdentity oldOwnIdentity : currentOwnIdentities.values()) {
 289                                 if (!newOwnIdentities.containsKey(oldOwnIdentity.getId())) {
 290                                         identityListenerManager.fireOwnIdentityRemoved(oldOwnIdentity);
 291                                         currentTrustedIdentities.remove(oldOwnIdentity);
 292                                 }
 293                         }
 294
 295                         /* find added own identities. */
 296                         for (OwnIdentity currentOwnIdentity : newOwnIdentities.values()) {
 297                                 if (!currentOwnIdentities.containsKey(currentOwnIdentity.getId())) {
 298                                         identityListenerManager.fireOwnIdentityAdded(currentOwnIdentity);
 299                                 }
 300                         }
 301
 302                         currentOwnIdentities.clear();
 303                         currentOwnIdentities.putAll(newOwnIdentities);
 304                 }
 305         }
 306
 307         /**
 308          * Checks the given identities for changes since the last check.
 309          *
 310          * @param ownIdentity
 311          *            The own identity trusting the given identities
 312          * @param trustedIdentities
 313          *            The trusted identities
 314          */
 315         private void checkTrustedIdentities(OwnIdentity ownIdentity, Map<String, Identity> trustedIdentities) {
 316
 317                 @SuppressWarnings("hiding")
 318                 Map<String, Identity> currentTrustedIdentities = new HashMap<String, Identity>();
 319                 synchronized (syncObject) {
 320                         if (this.currentTrustedIdentities.containsKey(ownIdentity)) {
 321                                 for (Identity identity : this.currentTrustedIdentities.get(ownIdentity)) {
 322                                         currentTrustedIdentities.put(identity.getId(), identity);
 323                                 }
 324                         }
 325                 }
 326
 327                 /* find new identities. */
 328                 for (Identity currentIdentity : trustedIdentities.values()) {
 329                         if (!currentTrustedIdentities.containsKey(currentIdentity.getId())) {
 330                                 identityListenerManager.fireIdentityAdded(ownIdentity, currentIdentity);
 331                         }
 332                 }
 333
 334                 /* find removed identities. */
 335                 for (Identity oldIdentity : currentTrustedIdentities.values()) {
 336                         if (!trustedIdentities.containsKey(oldIdentity.getId())) {
 337                                 identityListenerManager.fireIdentityRemoved(ownIdentity, oldIdentity);
 338                         }
 339                 }
 340
 341                 /* check for changes in the contexts. */
 342                 for (Identity oldIdentity : currentTrustedIdentities.values()) {
 343                         if (!trustedIdentities.containsKey(oldIdentity.getId())) {
 344                                 continue;
 345                         }
 346                         Identity newIdentity = trustedIdentities.get(oldIdentity.getId());
 347                         Set<String> oldContexts = oldIdentity.getContexts();
 348                         Set<String> newContexts = newIdentity.getContexts();
 349                         if (oldContexts.size() != newContexts.size()) {
 350                                 identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity);
 351                                 continue;
 352                         }
 353                         boolean changed = false;
 354                         for (String oldContext : oldContexts) {
 355                                 if (!newContexts.contains(oldContext)) {
 356                                         identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity);
 357                                         changed = true;
 358                                         break;
 359                                 }
 360                         }
 361                         if (changed) {
 362                                 continue;
 363                         }
 364                         Map<String, String> oldProperties = oldIdentity.getProperties();
 365                         Map<String, String> newProperties = newIdentity.getProperties();
 366                         if (oldProperties.size() != newProperties.size()) {
 367                                 identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity);
 368                                 continue;
 369                         }
 370                         for (Entry<String, String> oldProperty : oldProperties.entrySet()) {
 371                                 if (!newProperties.containsKey(oldProperty.getKey()) || !newProperties.get(oldProperty.getKey()).equals(oldProperty.getValue())) {
 372                                         identityListenerManager.fireIdentityUpdated(ownIdentity, newIdentity);
 373                                         break;
 374                                 }
 375                         }
 376                 }
 377
 378                 synchronized (syncObject) {
 379                         this.currentTrustedIdentities.put(ownIdentity, trustedIdentities.values());
 380                 }
 381
 382         }
 383
 384 }