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                 updateJobs.add(new SetTrustJob(truster, trustee, score, comment));
 109         }
 110
 111         //
 112         // SERVICE METHODS
 113         //
 114
 115         /**
 116          * {@inheritDoc}
 117          */
 118         @Override
 119         protected void serviceRun() {
 120                 while (!shouldStop()) {
 121                         try {
 122                                 TrustUpdateJob updateJob = updateJobs.take();
 123                                 if (shouldStop() || (updateJob == stopJob)) {
 124                                         break;
 125                                 }
 126                                 updateJob.run();
 127                         } catch (InterruptedException ie1) {
 128                                 /* happens, ignore, loop. */
 129                         }
 130                 }
 131         }
 132
 133         /**
 134          * {@inheritDoc}
 135          */
 136         @Override
 137         protected void serviceStop() {
 138                 try {
 139                         updateJobs.put(stopJob);
 140                 } catch (InterruptedException ie1) {
 141                         /* the queue is unbounded so it should never block. */
 142                 }
 143         }
 144
 145         /**
 146          * Base class for trust update jobs.
 147          *
 148          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 149          */
 150         private static class TrustUpdateJob {
 151
 152                 /** The identity giving the trust. */
 153                 protected final OwnIdentity truster;
 154
 155                 /** The identity receiving the trust. */
 156                 protected final Identity trustee;
 157
 158                 /**
 159                  * Creates a new trust update job.
 160                  *
 161                  * @param truster
 162                  *            The identity giving the trust
 163                  * @param trustee
 164                  *            The identity receiving the trust
 165                  */
 166                 public TrustUpdateJob(OwnIdentity truster, Identity trustee) {
 167                         this.truster = truster;
 168                         this.trustee = trustee;
 169                 }
 170
 171                 //
 172                 // ACCESSORS
 173                 //
 174
 175                 /**
 176                  * Performs the actual update operation.
 177                  * <p>
 178                  * The implementation of this class does nothing.
 179                  */
 180                 public void run() {
 181                         /* does nothing. */
 182                 }
 183
 184                 //
 185                 // OBJECT METHODS
 186                 //
 187
 188                 /**
 189                  * {@inheritDoc}
 190                  */
 191                 @Override
 192                 public boolean equals(Object object) {
 193                         if ((object == null) || !object.getClass().equals(getClass())) {
 194                                 return false;
 195                         }
 196                         TrustUpdateJob updateJob = (TrustUpdateJob) object;
 197                         return ((truster == null) ? (updateJob.truster == null) : updateJob.truster.equals(truster)) && ((trustee == null) ? (updateJob.trustee == null) : updateJob.trustee.equals(trustee));
 198                 }
 199
 200                 /**
 201                  * {@inheritDoc}
 202                  */
 203                 @Override
 204                 public int hashCode() {
 205                         return ((truster == null) ? 0 : truster.hashCode()) ^ ((trustee == null) ? 0 : trustee.hashCode());
 206                 }
 207
 208                 /**
 209                  * {@inheritDoc}
 210                  */
 211                 @Override
 212                 public String toString() {
 213                         return String.format("%s[truster=%s,trustee=%s]", getClass().getSimpleName(), (truster == null) ? null : truster.getId(), (trustee == null) ? null : trustee.getId());
 214                 }
 215
 216         }
 217
 218         /**
 219          * Update job that sets the trust relation between two identities.
 220          *
 221          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 222          */
 223         private class SetTrustJob extends TrustUpdateJob {
 224
 225                 /** The score of the relation. */
 226                 private final Integer score;
 227
 228                 /** The comment of the relation. */
 229                 private final String comment;
 230
 231                 /**
 232                  * Creates a new set trust job.
 233                  *
 234                  * @param truster
 235                  *            The identity giving the trust
 236                  * @param trustee
 237                  *            The identity receiving the trust
 238                  * @param score
 239                  *            The score of the trust (from -100 to 100, may be
 240                  *            {@code null} to remote the trust relation completely)
 241                  * @param comment
 242                  *            The comment of the trust relation
 243                  */
 244                 public SetTrustJob(OwnIdentity truster, Identity trustee, Integer score, String comment) {
 245                         super(truster, trustee);
 246                         this.score = score;
 247                         this.comment = comment;
 248                 }
 249
 250                 /**
 251                  * {@inheritDoc}
 252                  */
 253                 @Override
 254                 @SuppressWarnings("synthetic-access")
 255                 public void run() {
 256                         try {
 257                                 if (score != null) {
 258                                         if (trustee instanceof DefaultIdentity) {
 259                                                 ((DefaultIdentity) trustee).setTrust(truster, new Trust(score, null, 0));
 260                                         }
 261                                         webOfTrustConnector.setTrust(truster, trustee, score, comment);
 262                                 } else {
 263                                         if (trustee instanceof DefaultIdentity) {
 264                                                 ((DefaultIdentity) trustee).setTrust(truster, null);
 265                                         }
 266                                         webOfTrustConnector.removeTrust(truster, trustee);
 267                                 }
 268                         } catch (WebOfTrustException wote1) {
 269                                 logger.log(Level.WARNING, "Could not set Trust value for " + truster + " -> " + trustee + " to " + score + " (" + comment + ")!", wote1);
 270                         }
 271                 }
 272
 273         }
 274
 275         /**
 276          * Update job that retrieves the trust relation between two identities.
 277          *
 278          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 279          */
 280         private class GetTrustJob extends TrustUpdateJob {
 281
 282                 /**
 283                  * Creates a new trust update job.
 284                  *
 285                  * @param truster
 286                  *            The identity giving the trust
 287                  * @param trustee
 288                  *            The identity receiving the trust
 289                  */
 290                 public GetTrustJob(OwnIdentity truster, Identity trustee) {
 291                         super(truster, trustee);
 292                 }
 293
 294                 /**
 295                  * {@inheritDoc}
 296                  */
 297                 @Override
 298                 @SuppressWarnings("synthetic-access")
 299                 public void run() {
 300                         try {
 301                                 Trust trust = webOfTrustConnector.getTrust(truster, trustee);
 302                                 if (trustee instanceof DefaultIdentity) {
 303                                         ((DefaultIdentity) trustee).setTrust(truster, trust);
 304                                 }
 305                         } catch (PluginException pe1) {
 306                                 logger.log(Level.WARNING, "Could not get Trust value for " + truster + " -> " + trustee + "!", pe1);
 307                         }
 308                 }
 309         }
 310
 311 }