src/main/java/net/pterodactylus/sone/core/TrustUpdater.java

   1 /*
   2  * Sone - TrustUpdater.java - Copyright © 2012 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.sone.core;
  19
  20 import java.util.concurrent.BlockingQueue;
  21 import java.util.concurrent.LinkedBlockingQueue;
  22 import java.util.logging.Level;
  23 import java.util.logging.Logger;
  24
  25 import net.pterodactylus.sone.freenet.plugin.PluginException;
  26 import net.pterodactylus.sone.freenet.wot.DefaultIdentity;
  27 import net.pterodactylus.sone.freenet.wot.Identity;
  28 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
  29 import net.pterodactylus.sone.freenet.wot.Trust;
  30 import net.pterodactylus.sone.freenet.wot.WebOfTrustConnector;
  31 import net.pterodactylus.sone.freenet.wot.WebOfTrustException;
  32 import net.pterodactylus.util.logging.Logging;
  33 import net.pterodactylus.util.service.AbstractService;
  34
  35 /**
  36  * Updates identity’s trust in a background thread because getting updates from
  37  * the WebOfTrust plugin can potentially last quite long.
  38  *
  39  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  40  */
  41 public class TrustUpdater extends AbstractService {
  42
  43         /** The logger. */
  44         private static final Logger logger = Logging.getLogger(TrustUpdater.class);
  45
  46         /** Stop job. */
  47         private static final TrustUpdateJob stopJob = new TrustUpdateJob(null, null);
  48
  49         /** The web of trust connector. */
  50         private final WebOfTrustConnector webOfTrustConnector;
  51
  52         /** The queue for jobs. */
  53         private final BlockingQueue<TrustUpdateJob> updateJobs = new LinkedBlockingQueue<TrustUpdateJob>();
  54
  55         /**
  56          * Creates a new trust updater.
  57          *
  58          * @param webOfTrustConnector
  59          *            The web of trust connector
  60          */
  61         public TrustUpdater(WebOfTrustConnector webOfTrustConnector) {
  62                 super("Trust Updater");
  63                 this.webOfTrustConnector = webOfTrustConnector;
  64         }
  65
  66         //
  67         // ACTIONS
  68         //
  69
  70         /**
  71          * Retrieves the trust relation between the truster and the trustee. This
  72          * method will return immediately and perform a trust update in the
  73          * background.
  74          *
  75          * @param truster
  76          *            The identity giving the trust
  77          * @param trustee
  78          *            The identity receiving the trust
  79          */
  80         public void getTrust(OwnIdentity truster, Identity trustee) {
  81                 GetTrustJob getTrustJob = new GetTrustJob(truster, trustee);
  82                 if (!updateJobs.contains(getTrustJob)) {
  83                         logger.log(Level.FINER, "Adding Trust Update Job: " + getTrustJob);
  84                         try {
  85                                 updateJobs.put(getTrustJob);
  86                         } catch (InterruptedException ie1) {
  87                                 /* the queue is unbounded so it should never block. */
  88                         }
  89                 }
  90         }
  91
  92         /**
  93          * Updates the trust relation between the truster and the trustee. This
  94          * method will return immediately and perform a trust update in the
  95          * background.
  96          *
  97          * @param truster
  98          *            The identity giving the trust
  99          * @param trustee
 100          *            The identity receiving the trust
 101          * @param score
 102          *            The new level of trust (from -100 to 100, may be {@code null}
 103          *            to remove the trust completely)
 104          * @param comment
 105          *            The comment of the trust relation
 106          */
 107         public void setTrust(OwnIdentity truster, Identity trustee, Integer score, String comment) {
 108                 SetTrustJob setTrustJob = new SetTrustJob(truster, trustee, score, comment);
 109                 if (updateJobs.contains(setTrustJob)) {
 110                         updateJobs.remove(setTrustJob);
 111                 }
 112                 logger.log(Level.FINER, "Adding Trust Update Job: " + setTrustJob);
 113                 try {
 114                         updateJobs.put(setTrustJob);
 115                 } catch (InterruptedException e) {
 116                         /* the queue is unbounded so it should never block. */
 117                 }
 118         }
 119
 120         //
 121         // SERVICE METHODS
 122         //
 123
 124         /**
 125          * {@inheritDoc}
 126          */
 127         @Override
 128         protected void serviceRun() {
 129                 while (!shouldStop()) {
 130                         try {
 131                                 TrustUpdateJob updateJob = updateJobs.take();
 132                                 if (shouldStop() || (updateJob == stopJob)) {
 133                                         break;
 134                                 }
 135                                 updateJob.run();
 136                         } catch (InterruptedException ie1) {
 137                                 /* happens, ignore, loop. */
 138                         }
 139                 }
 140         }
 141
 142         /**
 143          * {@inheritDoc}
 144          */
 145         @Override
 146         protected void serviceStop() {
 147                 try {
 148                         updateJobs.put(stopJob);
 149                 } catch (InterruptedException ie1) {
 150                         /* the queue is unbounded so it should never block. */
 151                 }
 152         }
 153
 154         /**
 155          * Base class for trust update jobs.
 156          *
 157          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 158          */
 159         private static class TrustUpdateJob {
 160
 161                 /** The identity giving the trust. */
 162                 protected final OwnIdentity truster;
 163
 164                 /** The identity receiving the trust. */
 165                 protected final Identity trustee;
 166
 167                 /**
 168                  * Creates a new trust update job.
 169                  *
 170                  * @param truster
 171                  *            The identity giving the trust
 172                  * @param trustee
 173                  *            The identity receiving the trust
 174                  */
 175                 public TrustUpdateJob(OwnIdentity truster, Identity trustee) {
 176                         this.truster = truster;
 177                         this.trustee = trustee;
 178                 }
 179
 180                 //
 181                 // ACCESSORS
 182                 //
 183
 184                 /**
 185                  * Performs the actual update operation.
 186                  * <p>
 187                  * The implementation of this class does nothing.
 188                  */
 189                 public void run() {
 190                         /* does nothing. */
 191                 }
 192
 193                 //
 194                 // OBJECT METHODS
 195                 //
 196
 197                 /**
 198                  * {@inheritDoc}
 199                  */
 200                 @Override
 201                 public boolean equals(Object object) {
 202                         if ((object == null) || !object.getClass().equals(getClass())) {
 203                                 return false;
 204                         }
 205                         TrustUpdateJob updateJob = (TrustUpdateJob) object;
 206                         return ((truster == null) ? (updateJob.truster == null) : updateJob.truster.equals(truster)) && ((trustee == null) ? (updateJob.trustee == null) : updateJob.trustee.equals(trustee));
 207                 }
 208
 209                 /**
 210                  * {@inheritDoc}
 211                  */
 212                 @Override
 213                 public int hashCode() {
 214                         return ((truster == null) ? 0 : truster.hashCode()) ^ ((trustee == null) ? 0 : trustee.hashCode());
 215                 }
 216
 217                 /**
 218                  * {@inheritDoc}
 219                  */
 220                 @Override
 221                 public String toString() {
 222                         return String.format("%s[truster=%s,trustee=%s]", getClass().getSimpleName(), (truster == null) ? null : truster.getId(), (trustee == null) ? null : trustee.getId());
 223                 }
 224
 225         }
 226
 227         /**
 228          * Update job that sets the trust relation between two identities.
 229          *
 230          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 231          */
 232         private class SetTrustJob extends TrustUpdateJob {
 233
 234                 /** The score of the relation. */
 235                 private final Integer score;
 236
 237                 /** The comment of the relation. */
 238                 private final String comment;
 239
 240                 /**
 241                  * Creates a new set trust job.
 242                  *
 243                  * @param truster
 244                  *            The identity giving the trust
 245                  * @param trustee
 246                  *            The identity receiving the trust
 247                  * @param score
 248                  *            The score of the trust (from -100 to 100, may be
 249                  *            {@code null} to remote the trust relation completely)
 250                  * @param comment
 251                  *            The comment of the trust relation
 252                  */
 253                 public SetTrustJob(OwnIdentity truster, Identity trustee, Integer score, String comment) {
 254                         super(truster, trustee);
 255                         this.score = score;
 256                         this.comment = comment;
 257                 }
 258
 259                 /**
 260                  * {@inheritDoc}
 261                  */
 262                 @Override
 263                 @SuppressWarnings("synthetic-access")
 264                 public void run() {
 265                         try {
 266                                 if (score != null) {
 267                                         if (trustee instanceof DefaultIdentity) {
 268                                                 ((DefaultIdentity) trustee).setTrust(truster, new Trust(score, null, 0));
 269                                         }
 270                                         webOfTrustConnector.setTrust(truster, trustee, score, comment);
 271                                 } else {
 272                                         if (trustee instanceof DefaultIdentity) {
 273                                                 ((DefaultIdentity) trustee).setTrust(truster, null);
 274                                         }
 275                                         webOfTrustConnector.removeTrust(truster, trustee);
 276                                 }
 277                         } catch (WebOfTrustException wote1) {
 278                                 logger.log(Level.WARNING, "Could not set Trust value for " + truster + " -> " + trustee + " to " + score + " (" + comment + ")!", wote1);
 279                         }
 280                 }
 281
 282         }
 283
 284         /**
 285          * Update job that retrieves the trust relation between two identities.
 286          *
 287          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 288          */
 289         private class GetTrustJob extends TrustUpdateJob {
 290
 291                 /**
 292                  * Creates a new trust update job.
 293                  *
 294                  * @param truster
 295                  *            The identity giving the trust
 296                  * @param trustee
 297                  *            The identity receiving the trust
 298                  */
 299                 public GetTrustJob(OwnIdentity truster, Identity trustee) {
 300                         super(truster, trustee);
 301                 }
 302
 303                 /**
 304                  * {@inheritDoc}
 305                  */
 306                 @Override
 307                 @SuppressWarnings("synthetic-access")
 308                 public void run() {
 309                         try {
 310                                 Trust trust = webOfTrustConnector.getTrust(truster, trustee);
 311                                 if (trustee instanceof DefaultIdentity) {
 312                                         ((DefaultIdentity) trustee).setTrust(truster, trust);
 313                                 }
 314                         } catch (PluginException pe1) {
 315                                 logger.log(Level.WARNING, "Could not get Trust value for " + truster + " -> " + trustee + "!", pe1);
 316                         }
 317                 }
 318         }
 319
 320 }