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

   1 /*
   2  * Sone - WebOfTrustUpdater.java - Copyright © 2013 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 static com.google.common.base.Preconditions.checkNotNull;
  21
  22 import java.util.concurrent.BlockingQueue;
  23 import java.util.concurrent.LinkedBlockingQueue;
  24 import java.util.logging.Level;
  25 import java.util.logging.Logger;
  26
  27 import net.pterodactylus.sone.freenet.plugin.PluginException;
  28 import net.pterodactylus.sone.freenet.wot.DefaultIdentity;
  29 import net.pterodactylus.sone.freenet.wot.Identity;
  30 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
  31 import net.pterodactylus.sone.freenet.wot.Trust;
  32 import net.pterodactylus.sone.freenet.wot.WebOfTrustConnector;
  33 import net.pterodactylus.sone.freenet.wot.WebOfTrustException;
  34 import net.pterodactylus.util.logging.Logging;
  35 import net.pterodactylus.util.service.AbstractService;
  36
  37 import com.google.inject.Inject;
  38
  39 /**
  40  * Updates WebOfTrust identity data in a background thread because communicating
  41  * with the WebOfTrust plugin can potentially last quite long.
  42  *
  43  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  44  */
  45 public class WebOfTrustUpdater extends AbstractService {
  46
  47         /** The logger. */
  48         private static final Logger logger = Logging.getLogger(WebOfTrustUpdater.class);
  49
  50         /** Stop job. */
  51         @SuppressWarnings("synthetic-access")
  52         private final WebOfTrustUpdateJob stopJob = new WebOfTrustUpdateJob();
  53
  54         /** The web of trust connector. */
  55         private final WebOfTrustConnector webOfTrustConnector;
  56
  57         /** The queue for jobs. */
  58         private final BlockingQueue<WebOfTrustUpdateJob> updateJobs = new LinkedBlockingQueue<WebOfTrustUpdateJob>();
  59
  60         /**
  61          * Creates a new trust updater.
  62          *
  63          * @param webOfTrustConnector
  64          *            The web of trust connector
  65          */
  66         @Inject
  67         public WebOfTrustUpdater(WebOfTrustConnector webOfTrustConnector) {
  68                 super("Trust Updater");
  69                 this.webOfTrustConnector = webOfTrustConnector;
  70         }
  71
  72         //
  73         // ACTIONS
  74         //
  75
  76         /**
  77          * Updates the trust relation between the truster and the trustee. This
  78          * method will return immediately and perform a trust update in the
  79          * background.
  80          *
  81          * @param truster
  82          *            The identity giving the trust
  83          * @param trustee
  84          *            The identity receiving the trust
  85          * @param score
  86          *            The new level of trust (from -100 to 100, may be {@code null}
  87          *            to remove the trust completely)
  88          * @param comment
  89          *            The comment of the trust relation
  90          */
  91         public void setTrust(OwnIdentity truster, Identity trustee, Integer score, String comment) {
  92                 SetTrustJob setTrustJob = new SetTrustJob(truster, trustee, score, comment);
  93                 if (updateJobs.contains(setTrustJob)) {
  94                         updateJobs.remove(setTrustJob);
  95                 }
  96                 logger.log(Level.FINER, "Adding Trust Update Job: " + setTrustJob);
  97                 try {
  98                         updateJobs.put(setTrustJob);
  99                 } catch (InterruptedException e) {
 100                         /* the queue is unbounded so it should never block. */
 101                 }
 102         }
 103
 104         /**
 105          * Adds the given context to the given own identity.
 106          *
 107          * @param ownIdentity
 108          *            The own identity to add the context to
 109          * @param context
 110          *            The context to add
 111          */
 112         public void addContext(OwnIdentity ownIdentity, String context) {
 113                 addContextWait(ownIdentity, context, false);
 114         }
 115
 116         /**
 117          * Adds the given context to the given own identity, waiting for completion
 118          * of the operation.
 119          *
 120          * @param ownIdentity
 121          *            The own identity to add the context to
 122          * @param context
 123          *            The context to add
 124          * @return {@code true} if the context was added successfully, {@code false}
 125          *         otherwise
 126          */
 127         public boolean addContextWait(OwnIdentity ownIdentity, String context) {
 128                 return addContextWait(ownIdentity, context, true);
 129         }
 130
 131         /**
 132          * Adds the given context to the given own identity, waiting for completion
 133          * of the operation.
 134          *
 135          * @param ownIdentity
 136          *            The own identity to add the context to
 137          * @param context
 138          *            The context to add
 139          * @param wait
 140          *            {@code true} to wait for the end of the operation,
 141          *            {@code false} to return immediately
 142          * @return {@code true} if the context was added successfully, {@code false}
 143          *         if the context was not added successfully, or if the job should
 144          *         not wait for completion
 145          */
 146         private boolean addContextWait(OwnIdentity ownIdentity, String context, boolean wait) {
 147                 AddContextJob addContextJob = new AddContextJob(ownIdentity, context);
 148                 if (!updateJobs.contains(addContextJob)) {
 149                         logger.log(Level.FINER, "Adding Context Job: " + addContextJob);
 150                         try {
 151                                 updateJobs.put(addContextJob);
 152                         } catch (InterruptedException ie1) {
 153                                 /* the queue is unbounded so it should never block. */
 154                         }
 155                         if (wait) {
 156                                 return addContextJob.waitForCompletion();
 157                         }
 158                 } else if (wait) {
 159                         for (WebOfTrustUpdateJob updateJob : updateJobs) {
 160                                 if (updateJob.equals(addContextJob)) {
 161                                         return updateJob.waitForCompletion();
 162                                 }
 163                         }
 164                 }
 165                 return false;
 166         }
 167
 168         /**
 169          * Removes the given context from the given own identity.
 170          *
 171          * @param ownIdentity
 172          *            The own identity to remove the context from
 173          * @param context
 174          *            The context to remove
 175          */
 176         public void removeContext(OwnIdentity ownIdentity, String context) {
 177                 RemoveContextJob removeContextJob = new RemoveContextJob(ownIdentity, context);
 178                 if (!updateJobs.contains(removeContextJob)) {
 179                         logger.log(Level.FINER, "Adding Context Job: " + removeContextJob);
 180                         try {
 181                                 updateJobs.put(removeContextJob);
 182                         } catch (InterruptedException ie1) {
 183                                 /* the queue is unbounded so it should never block. */
 184                         }
 185                 }
 186         }
 187
 188         /**
 189          * Sets a property on the given own identity.
 190          *
 191          * @param ownIdentity
 192          *            The own identity to set the property on
 193          * @param propertyName
 194          *            The name of the property to set
 195          * @param propertyValue
 196          *            The value of the property to set
 197          */
 198         public void setProperty(OwnIdentity ownIdentity, String propertyName, String propertyValue) {
 199                 SetPropertyJob setPropertyJob = new SetPropertyJob(ownIdentity, propertyName, propertyValue);
 200                 if (updateJobs.contains(setPropertyJob)) {
 201                         updateJobs.remove(setPropertyJob);
 202                 }
 203                 logger.log(Level.FINER, "Adding Property Job: " + setPropertyJob);
 204                 try {
 205                         updateJobs.put(setPropertyJob);
 206                 } catch (InterruptedException e) {
 207                         /* the queue is unbounded so it should never block. */
 208                 }
 209         }
 210
 211         /**
 212          * Removes a property from the given own identity.
 213          *
 214          * @param ownIdentity
 215          *            The own identity to remove the property from
 216          * @param propertyName
 217          *            The name of the property to remove
 218          */
 219         public void removeProperty(OwnIdentity ownIdentity, String propertyName) {
 220                 setProperty(ownIdentity, propertyName, null);
 221         }
 222
 223         //
 224         // SERVICE METHODS
 225         //
 226
 227         /**
 228          * {@inheritDoc}
 229          */
 230         @Override
 231         protected void serviceRun() {
 232                 while (!shouldStop()) {
 233                         try {
 234                                 WebOfTrustUpdateJob updateJob = updateJobs.take();
 235                                 if (shouldStop() || (updateJob == stopJob)) {
 236                                         break;
 237                                 }
 238                                 logger.log(Level.FINE, "Running Trust Update Job: " + updateJob);
 239                                 long startTime = System.currentTimeMillis();
 240                                 updateJob.run();
 241                                 long endTime = System.currentTimeMillis();
 242                                 logger.log(Level.FINE, "Trust Update Job finished, took " + (endTime - startTime) + " ms.");
 243                         } catch (InterruptedException ie1) {
 244                                 /* happens, ignore, loop. */
 245                         }
 246                 }
 247         }
 248
 249         /**
 250          * {@inheritDoc}
 251          */
 252         @Override
 253         protected void serviceStop() {
 254                 try {
 255                         updateJobs.put(stopJob);
 256                 } catch (InterruptedException ie1) {
 257                         /* the queue is unbounded so it should never block. */
 258                 }
 259         }
 260
 261         /**
 262          * Base class for WebOfTrust update jobs.
 263          *
 264          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 265          */
 266         private class WebOfTrustUpdateJob {
 267
 268                 /** Object for synchronization. */
 269                 @SuppressWarnings("hiding")
 270                 private final Object syncObject = new Object();
 271
 272                 /** Whether the job has finished. */
 273                 private boolean finished;
 274
 275                 /** Whether the job was successful. */
 276                 private boolean success;
 277
 278                 //
 279                 // ACTIONS
 280                 //
 281
 282                 /**
 283                  * Performs the actual update operation.
 284                  * <p>
 285                  * The implementation of this class does nothing.
 286                  */
 287                 public void run() {
 288                         /* does nothing. */
 289                 }
 290
 291                 /**
 292                  * Waits for completion of this job or stopping of the WebOfTrust
 293                  * updater.
 294                  *
 295                  * @return {@code true} if this job finished successfully, {@code false}
 296                  *         otherwise
 297                  * @see WebOfTrustUpdater#stop()
 298                  */
 299                 @SuppressWarnings("synthetic-access")
 300                 public boolean waitForCompletion() {
 301                         synchronized (syncObject) {
 302                                 while (!finished && !shouldStop()) {
 303                                         try {
 304                                                 syncObject.wait();
 305                                         } catch (InterruptedException ie1) {
 306                                                 /* we’re looping, ignore. */
 307                                         }
 308                                 }
 309                                 return success;
 310                         }
 311                 }
 312
 313                 //
 314                 // PROTECTED METHODS
 315                 //
 316
 317                 /**
 318                  * Signals that this job has finished.
 319                  *
 320                  * @param success
 321                  *            {@code true} if this job finished successfully,
 322                  *            {@code false} otherwise
 323                  */
 324                 protected void finish(boolean success) {
 325                         synchronized (syncObject) {
 326                                 finished = true;
 327                                 this.success = success;
 328                                 syncObject.notifyAll();
 329                         }
 330                 }
 331
 332         }
 333
 334         /**
 335          * Update job that sets the trust relation between two identities.
 336          *
 337          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 338          */
 339         private class SetTrustJob extends WebOfTrustUpdateJob {
 340
 341                 /** The identity giving the trust. */
 342                 private final OwnIdentity truster;
 343
 344                 /** The identity receiving the trust. */
 345                 private final Identity trustee;
 346
 347                 /** The score of the relation. */
 348                 private final Integer score;
 349
 350                 /** The comment of the relation. */
 351                 private final String comment;
 352
 353                 /**
 354                  * Creates a new set trust job.
 355                  *
 356                  * @param truster
 357                  *            The identity giving the trust
 358                  * @param trustee
 359                  *            The identity receiving the trust
 360                  * @param score
 361                  *            The score of the trust (from -100 to 100, may be
 362                  *            {@code null} to remote the trust relation completely)
 363                  * @param comment
 364                  *            The comment of the trust relation
 365                  */
 366                 public SetTrustJob(OwnIdentity truster, Identity trustee, Integer score, String comment) {
 367                         this.truster = truster;
 368                         this.trustee = trustee;
 369                         this.score = score;
 370                         this.comment = comment;
 371                 }
 372
 373                 /**
 374                  * {@inheritDoc}
 375                  */
 376                 @Override
 377                 @SuppressWarnings("synthetic-access")
 378                 public void run() {
 379                         try {
 380                                 if (score != null) {
 381                                         if (trustee instanceof DefaultIdentity) {
 382                                                 ((DefaultIdentity) trustee).setTrust(truster, new Trust(score, null, 0));
 383                                         }
 384                                         webOfTrustConnector.setTrust(truster, trustee, score, comment);
 385                                 } else {
 386                                         if (trustee instanceof DefaultIdentity) {
 387                                                 ((DefaultIdentity) trustee).setTrust(truster, null);
 388                                         }
 389                                         webOfTrustConnector.removeTrust(truster, trustee);
 390                                 }
 391                                 finish(true);
 392                         } catch (WebOfTrustException wote1) {
 393                                 logger.log(Level.WARNING, "Could not set Trust value for " + truster + " -> " + trustee + " to " + score + " (" + comment + ")!", wote1);
 394                                 finish(false);
 395                         }
 396                 }
 397
 398                 //
 399                 // OBJECT METHODS
 400                 //
 401
 402                 /** {@inheritDoc} */
 403                 @Override
 404                 public boolean equals(Object object) {
 405                         if ((object == null) || !object.getClass().equals(getClass())) {
 406                                 return false;
 407                         }
 408                         SetTrustJob updateJob = (SetTrustJob) object;
 409                         return ((truster == null) ? (updateJob.truster == null) : updateJob.truster.equals(truster)) && ((trustee == null) ? (updateJob.trustee == null) : updateJob.trustee.equals(trustee));
 410                 }
 411
 412                 /** {@inheritDoc} */
 413                 @Override
 414                 public int hashCode() {
 415                         return getClass().hashCode() ^ ((truster == null) ? 0 : truster.hashCode()) ^ ((trustee == null) ? 0 : trustee.hashCode());
 416                 }
 417
 418                 /** {@inheritDoc} */
 419                 @Override
 420                 public String toString() {
 421                         return String.format("%s[truster=%s,trustee=%s]", getClass().getSimpleName(), (truster == null) ? null : truster.getId(), (trustee == null) ? null : trustee.getId());
 422                 }
 423
 424         }
 425
 426         /**
 427          * Base class for context updates of an {@link OwnIdentity}.
 428          *
 429          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 430          */
 431         private class WebOfTrustContextUpdateJob extends WebOfTrustUpdateJob {
 432
 433                 /** The own identity whose contexts to manage. */
 434                 protected final OwnIdentity ownIdentity;
 435
 436                 /** The context to update. */
 437                 protected final String context;
 438
 439                 /**
 440                  * Creates a new context update job.
 441                  *
 442                  * @param ownIdentity
 443                  *            The own identity to update
 444                  * @param context
 445                  *            The context to update
 446                  */
 447                 @SuppressWarnings("synthetic-access")
 448                 public WebOfTrustContextUpdateJob(OwnIdentity ownIdentity, String context) {
 449                         this.ownIdentity = checkNotNull(ownIdentity, "ownIdentity must not be null");
 450                         this.context = checkNotNull(context, "context must not be null");
 451                 }
 452
 453                 //
 454                 // OBJECT METHODS
 455                 //
 456
 457                 /**
 458                  * {@inheritDoc}
 459                  */
 460                 @Override
 461                 public boolean equals(Object object) {
 462                         if ((object == null) || !object.getClass().equals(getClass())) {
 463                                 return false;
 464                         }
 465                         WebOfTrustContextUpdateJob updateJob = (WebOfTrustContextUpdateJob) object;
 466                         return updateJob.ownIdentity.equals(ownIdentity) && updateJob.context.equals(context);
 467                 }
 468
 469                 /**
 470                  * {@inheritDoc}
 471                  */
 472                 @Override
 473                 public int hashCode() {
 474                         return getClass().hashCode() ^ ownIdentity.hashCode() ^ context.hashCode();
 475                 }
 476
 477                 /**
 478                  * {@inheritDoc}
 479                  */
 480                 @Override
 481                 public String toString() {
 482                         return String.format("%s[ownIdentity=%s,context=%s]", getClass().getSimpleName(), ownIdentity, context);
 483                 }
 484
 485         }
 486
 487         /**
 488          * Job that adds a context to an {@link OwnIdentity}.
 489          *
 490          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 491          */
 492         private class AddContextJob extends WebOfTrustContextUpdateJob {
 493
 494                 /**
 495                  * Creates a new add-context job.
 496                  *
 497                  * @param ownIdentity
 498                  *            The own identity whose contexts to manage
 499                  * @param context
 500                  *            The context to add
 501                  */
 502                 public AddContextJob(OwnIdentity ownIdentity, String context) {
 503                         super(ownIdentity, context);
 504                 }
 505
 506                 /**
 507                  * {@inheritDoc}
 508                  */
 509                 @Override
 510                 @SuppressWarnings("synthetic-access")
 511                 public void run() {
 512                         try {
 513                                 webOfTrustConnector.addContext(ownIdentity, context);
 514                                 ownIdentity.addContext(context);
 515                                 finish(true);
 516                         } catch (PluginException pe1) {
 517                                 logger.log(Level.WARNING, String.format("Could not add Context “%2$s” to Own Identity %1$s!", ownIdentity, context), pe1);
 518                                 finish(false);
 519                         }
 520                 }
 521
 522         }
 523
 524         /**
 525          * Job that removes a context from an {@link OwnIdentity}.
 526          *
 527          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 528          */
 529         private class RemoveContextJob extends WebOfTrustContextUpdateJob {
 530
 531                 /**
 532                  * Creates a new remove-context job.
 533                  *
 534                  * @param ownIdentity
 535                  *            The own identity whose contexts to manage
 536                  * @param context
 537                  *            The context to remove
 538                  */
 539                 public RemoveContextJob(OwnIdentity ownIdentity, String context) {
 540                         super(ownIdentity, context);
 541                 }
 542
 543                 /**
 544                  * {@inheritDoc}
 545                  */
 546                 @Override
 547                 @SuppressWarnings("synthetic-access")
 548                 public void run() {
 549                         try {
 550                                 webOfTrustConnector.removeContext(ownIdentity, context);
 551                                 ownIdentity.removeContext(context);
 552                                 finish(true);
 553                         } catch (PluginException pe1) {
 554                                 logger.log(Level.WARNING, String.format("Could not remove Context “%2$s” to Own Identity %1$s!", ownIdentity, context), pe1);
 555                                 finish(false);
 556                         }
 557                 }
 558
 559         }
 560
 561         /**
 562          * Base class for update jobs that deal with properties.
 563          *
 564          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 565          */
 566         private class WebOfTrustPropertyUpdateJob extends WebOfTrustUpdateJob {
 567
 568                 /** The own identity to update properties on. */
 569                 protected final OwnIdentity ownIdentity;
 570
 571                 /** The name of the property to update. */
 572                 protected final String propertyName;
 573
 574                 /**
 575                  * Creates a new property update job.
 576                  *
 577                  * @param ownIdentity
 578                  *            The own identity to update the property on
 579                  * @param propertyName
 580                  *            The name of the property to update
 581                  */
 582                 @SuppressWarnings("synthetic-access")
 583                 public WebOfTrustPropertyUpdateJob(OwnIdentity ownIdentity, String propertyName) {
 584                         this.ownIdentity = ownIdentity;
 585                         this.propertyName = propertyName;
 586                 }
 587
 588                 //
 589                 // OBJECT METHODS
 590                 //
 591
 592                 /**
 593                  * {@inheritDoc}
 594                  */
 595                 @Override
 596                 public boolean equals(Object object) {
 597                         if ((object == null) || !object.getClass().equals(getClass())) {
 598                                 return false;
 599                         }
 600                         WebOfTrustPropertyUpdateJob updateJob = (WebOfTrustPropertyUpdateJob) object;
 601                         return updateJob.ownIdentity.equals(ownIdentity) && updateJob.propertyName.equals(propertyName);
 602                 }
 603
 604                 /**
 605                  * {@inheritDoc}
 606                  */
 607                 @Override
 608                 public int hashCode() {
 609                         return getClass().hashCode() ^ ownIdentity.hashCode() ^ propertyName.hashCode();
 610                 }
 611
 612                 /**
 613                  * {@inheritDoc}
 614                  */
 615                 @Override
 616                 public String toString() {
 617                         return String.format("%s[ownIdentity=%s,propertyName=%s]", getClass().getSimpleName(), ownIdentity, propertyName);
 618                 }
 619
 620         }
 621
 622         /**
 623          * WebOfTrust update job that sets a property on an {@link OwnIdentity}.
 624          *
 625          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 626          */
 627         private class SetPropertyJob extends WebOfTrustPropertyUpdateJob {
 628
 629                 /** The value of the property to set. */
 630                 private final String propertyValue;
 631
 632                 /**
 633                  * Creates a new set-property job.
 634                  *
 635                  * @param ownIdentity
 636                  *            The own identity to set the property on
 637                  * @param propertyName
 638                  *            The name of the property to set
 639                  * @param propertyValue
 640                  *            The value of the property to set
 641                  */
 642                 public SetPropertyJob(OwnIdentity ownIdentity, String propertyName, String propertyValue) {
 643                         super(ownIdentity, propertyName);
 644                         this.propertyValue = propertyValue;
 645                 }
 646
 647                 /**
 648                  * {@inheritDoc}
 649                  */
 650                 @Override
 651                 @SuppressWarnings("synthetic-access")
 652                 public void run() {
 653                         try {
 654                                 if (propertyValue == null) {
 655                                         webOfTrustConnector.removeProperty(ownIdentity, propertyName);
 656                                         ownIdentity.removeProperty(propertyName);
 657                                 } else {
 658                                         webOfTrustConnector.setProperty(ownIdentity, propertyName, propertyValue);
 659                                         ownIdentity.setProperty(propertyName, propertyValue);
 660                                 }
 661                                 finish(true);
 662                         } catch (PluginException pe1) {
 663                                 logger.log(Level.WARNING, String.format("Could not set Property “%2$s” to “%3$s” on Own Identity %1$s!", ownIdentity, propertyName, propertyValue), pe1);
 664                                 finish(false);
 665                         }
 666                 }
 667
 668         }
 669
 670 }