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

   1 /*
   2  * Sone - WebOfTrustUpdaterImpl.java - Copyright © 2013–2020 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 import static java.util.logging.Logger.getLogger;
  22
  23 import java.util.concurrent.BlockingQueue;
  24 import java.util.concurrent.LinkedBlockingQueue;
  25 import java.util.logging.Level;
  26 import java.util.logging.Logger;
  27
  28 import net.pterodactylus.sone.freenet.plugin.PluginException;
  29 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
  30 import net.pterodactylus.sone.freenet.wot.WebOfTrustConnector;
  31 import net.pterodactylus.util.service.AbstractService;
  32
  33 import com.google.common.annotations.VisibleForTesting;
  34 import com.google.inject.Inject;
  35 import com.google.inject.Singleton;
  36
  37 /**
  38  * Updates WebOfTrust identity data in a background thread because communicating
  39  * with the WebOfTrust plugin can potentially last quite long.
  40  */
  41 @Singleton
  42 public class WebOfTrustUpdaterImpl extends AbstractService implements WebOfTrustUpdater {
  43
  44         /** The logger. */
  45         private static final Logger logger = getLogger(WebOfTrustUpdaterImpl.class.getName());
  46
  47         /** Stop job. */
  48         @SuppressWarnings("synthetic-access")
  49         private final WebOfTrustUpdateJob stopJob = new WebOfTrustUpdateJob();
  50
  51         /** The web of trust connector. */
  52         private final WebOfTrustConnector webOfTrustConnector;
  53
  54         /** The queue for jobs. */
  55         private final BlockingQueue<WebOfTrustUpdateJob> updateJobs = new LinkedBlockingQueue<>();
  56
  57         /**
  58          * Creates a new trust updater.
  59          *
  60          * @param webOfTrustConnector
  61          *              The web of trust connector
  62          */
  63         @Inject
  64         public WebOfTrustUpdaterImpl(WebOfTrustConnector webOfTrustConnector) {
  65                 super("Trust Updater");
  66                 this.webOfTrustConnector = webOfTrustConnector;
  67         }
  68
  69         //
  70         // ACTIONS
  71         //
  72
  73         /**
  74          * Adds the given context to the given own identity, waiting for completion of
  75          * the operation.
  76          *
  77          * @param ownIdentity
  78          *              The own identity to add the context to
  79          * @param context
  80          *              The context to add
  81          * @return {@code true} if the context was added successfully, {@code false}
  82          *         otherwise
  83          */
  84         @Override
  85         public boolean addContextWait(OwnIdentity ownIdentity, String context) {
  86                 AddContextJob addContextJob = new AddContextJob(ownIdentity, context);
  87                 if (!updateJobs.contains(addContextJob)) {
  88                         logger.log(Level.FINER, "Adding Context Job: " + addContextJob);
  89                         try {
  90                                 updateJobs.put(addContextJob);
  91                         } catch (InterruptedException ie1) {
  92                                 /* the queue is unbounded so it should never block. */
  93                         }
  94                         return addContextJob.waitForCompletion();
  95                 } else {
  96                         for (WebOfTrustUpdateJob updateJob : updateJobs) {
  97                                 if (updateJob.equals(addContextJob)) {
  98                                         return updateJob.waitForCompletion();
  99                                 }
 100                         }
 101                 }
 102                 return false;
 103         }
 104
 105         /**
 106          * Removes the given context from the given own identity.
 107          *
 108          * @param ownIdentity
 109          *              The own identity to remove the context from
 110          * @param context
 111          *              The context to remove
 112          */
 113         @Override
 114         public void removeContext(OwnIdentity ownIdentity, String context) {
 115                 RemoveContextJob removeContextJob = new RemoveContextJob(ownIdentity, context);
 116                 if (!updateJobs.contains(removeContextJob)) {
 117                         logger.log(Level.FINER, "Adding Context Job: " + removeContextJob);
 118                         try {
 119                                 updateJobs.put(removeContextJob);
 120                         } catch (InterruptedException ie1) {
 121                                 /* the queue is unbounded so it should never block. */
 122                         }
 123                 }
 124         }
 125
 126         /**
 127          * Sets a property on the given own identity.
 128          *
 129          * @param ownIdentity
 130          *              The own identity to set the property on
 131          * @param propertyName
 132          *              The name of the property to set
 133          * @param propertyValue
 134          *              The value of the property to set
 135          */
 136         @Override
 137         public void setProperty(OwnIdentity ownIdentity, String propertyName, String propertyValue) {
 138                 SetPropertyJob setPropertyJob = new SetPropertyJob(ownIdentity, propertyName, propertyValue);
 139                 if (updateJobs.contains(setPropertyJob)) {
 140                         updateJobs.remove(setPropertyJob);
 141                 }
 142                 logger.log(Level.FINER, "Adding Property Job: " + setPropertyJob);
 143                 try {
 144                         updateJobs.put(setPropertyJob);
 145                 } catch (InterruptedException e) {
 146                         /* the queue is unbounded so it should never block. */
 147                 }
 148         }
 149
 150         /**
 151          * Removes a property from the given own identity.
 152          *
 153          * @param ownIdentity
 154          *              The own identity to remove the property from
 155          * @param propertyName
 156          *              The name of the property to remove
 157          */
 158         @Override
 159         public void removeProperty(OwnIdentity ownIdentity, String propertyName) {
 160                 setProperty(ownIdentity, propertyName, null);
 161         }
 162
 163         //
 164         // SERVICE METHODS
 165         //
 166
 167         /** {@inheritDoc} */
 168         @Override
 169         protected void serviceRun() {
 170                 while (!shouldStop()) {
 171                         try {
 172                                 WebOfTrustUpdateJob updateJob = updateJobs.take();
 173                                 if (shouldStop()) {
 174                                         break;
 175                                 }
 176                                 logger.log(Level.FINE, "Running Trust Update Job: " + updateJob);
 177                                 long startTime = System.currentTimeMillis();
 178                                 updateJob.run();
 179                                 long endTime = System.currentTimeMillis();
 180                                 logger.log(Level.FINE, "Trust Update Job finished, took " + (endTime - startTime) + " ms.");
 181                         } catch (InterruptedException ie1) {
 182                                 /* happens, ignore, loop. */
 183                         }
 184                 }
 185         }
 186
 187         /** {@inheritDoc} */
 188         @Override
 189         protected void serviceStop() {
 190                 try {
 191                         updateJobs.put(stopJob);
 192                 } catch (InterruptedException ie1) {
 193                         /* the queue is unbounded so it should never block. */
 194                 }
 195         }
 196
 197         /**
 198          * Base class for WebOfTrust update jobs.
 199          */
 200         @VisibleForTesting
 201         class WebOfTrustUpdateJob implements Runnable {
 202
 203                 /** Object for synchronization. */
 204                 @SuppressWarnings("hiding")
 205                 private final Object syncObject = new Object();
 206
 207                 /** Whether the job has finished. */
 208                 private boolean finished;
 209
 210                 /** Whether the job was successful. */
 211                 private boolean success;
 212
 213                 //
 214                 // ACTIONS
 215                 //
 216
 217                 /**
 218                  * Performs the actual update operation.
 219                  * <p/>
 220                  * The implementation of this class does nothing.
 221                  */
 222                 @Override
 223                 public void run() {
 224                         /* does nothing. */
 225                 }
 226
 227                 /**
 228                  * Waits for completion of this job or stopping of the WebOfTrust updater.
 229                  *
 230                  * @return {@code true} if this job finished successfully, {@code false}
 231                  *         otherwise
 232                  * @see WebOfTrustUpdaterImpl#stop()
 233                  */
 234                 @SuppressWarnings("synthetic-access")
 235                 public boolean waitForCompletion() {
 236                         synchronized (syncObject) {
 237                                 while (!finished && !shouldStop()) {
 238                                         try {
 239                                                 syncObject.wait();
 240                                         } catch (InterruptedException ie1) {
 241                                                 /* we’re looping, ignore. */
 242                                         }
 243                                 }
 244                                 return success;
 245                         }
 246                 }
 247
 248                 //
 249                 // PROTECTED METHODS
 250                 //
 251
 252                 /**
 253                  * Signals that this job has finished.
 254                  *
 255                  * @param success
 256                  *              {@code true} if this job finished successfully, {@code false} otherwise
 257                  */
 258                 protected void finish(boolean success) {
 259                         synchronized (syncObject) {
 260                                 finished = true;
 261                                 this.success = success;
 262                                 syncObject.notifyAll();
 263                         }
 264                 }
 265
 266         }
 267
 268         /**
 269          * Base class for context updates of an {@link OwnIdentity}.
 270          */
 271         @VisibleForTesting
 272         class WebOfTrustContextUpdateJob extends WebOfTrustUpdateJob {
 273
 274                 /** The own identity whose contexts to manage. */
 275                 protected final OwnIdentity ownIdentity;
 276
 277                 /** The context to update. */
 278                 protected final String context;
 279
 280                 /**
 281                  * Creates a new context update job.
 282                  *
 283                  * @param ownIdentity
 284                  *              The own identity to update
 285                  * @param context
 286                  *              The context to update
 287                  */
 288                 @SuppressWarnings("synthetic-access")
 289                 public WebOfTrustContextUpdateJob(OwnIdentity ownIdentity, String context) {
 290                         this.ownIdentity = checkNotNull(ownIdentity, "ownIdentity must not be null");
 291                         this.context = checkNotNull(context, "context must not be null");
 292                 }
 293
 294                 //
 295                 // OBJECT METHODS
 296                 //
 297
 298                 /** {@inheritDoc} */
 299                 @Override
 300                 public boolean equals(Object object) {
 301                         if ((object == null) || !object.getClass().equals(getClass())) {
 302                                 return false;
 303                         }
 304                         WebOfTrustContextUpdateJob updateJob = (WebOfTrustContextUpdateJob) object;
 305                         return updateJob.ownIdentity.equals(ownIdentity) && updateJob.context.equals(context);
 306                 }
 307
 308                 /** {@inheritDoc} */
 309                 @Override
 310                 public int hashCode() {
 311                         return getClass().hashCode() ^ ownIdentity.hashCode() ^ context.hashCode();
 312                 }
 313
 314                 /** {@inheritDoc} */
 315                 @Override
 316                 public String toString() {
 317                         return String.format("%s[ownIdentity=%s,context=%s]", getClass().getSimpleName(), ownIdentity, context);
 318                 }
 319
 320         }
 321
 322         /**
 323          * Job that adds a context to an {@link OwnIdentity}.
 324          */
 325         @VisibleForTesting
 326         class AddContextJob extends WebOfTrustContextUpdateJob {
 327
 328                 /**
 329                  * Creates a new add-context job.
 330                  *
 331                  * @param ownIdentity
 332                  *              The own identity whose contexts to manage
 333                  * @param context
 334                  *              The context to add
 335                  */
 336                 public AddContextJob(OwnIdentity ownIdentity, String context) {
 337                         super(ownIdentity, context);
 338                 }
 339
 340                 /** {@inheritDoc} */
 341                 @Override
 342                 @SuppressWarnings("synthetic-access")
 343                 public void run() {
 344                         try {
 345                                 webOfTrustConnector.addContext(ownIdentity, context);
 346                                 ownIdentity.addContext(context);
 347                                 finish(true);
 348                         } catch (PluginException pe1) {
 349                                 logger.log(Level.WARNING, String.format("Could not add Context “%2$s” to Own Identity %1$s!", ownIdentity, context), pe1);
 350                                 finish(false);
 351                         }
 352                 }
 353
 354         }
 355
 356         /**
 357          * Job that removes a context from an {@link OwnIdentity}.
 358          */
 359         @VisibleForTesting
 360         class RemoveContextJob extends WebOfTrustContextUpdateJob {
 361
 362                 /**
 363                  * Creates a new remove-context job.
 364                  *
 365                  * @param ownIdentity
 366                  *              The own identity whose contexts to manage
 367                  * @param context
 368                  *              The context to remove
 369                  */
 370                 public RemoveContextJob(OwnIdentity ownIdentity, String context) {
 371                         super(ownIdentity, context);
 372                 }
 373
 374                 /** {@inheritDoc} */
 375                 @Override
 376                 @SuppressWarnings("synthetic-access")
 377                 public void run() {
 378                         try {
 379                                 webOfTrustConnector.removeContext(ownIdentity, context);
 380                                 ownIdentity.removeContext(context);
 381                                 finish(true);
 382                         } catch (PluginException pe1) {
 383                                 logger.log(Level.WARNING, String.format("Could not remove Context “%2$s” to Own Identity %1$s!", ownIdentity, context), pe1);
 384                                 finish(false);
 385                         }
 386                 }
 387
 388         }
 389
 390         /**
 391          * WebOfTrust update job that sets a property on an {@link OwnIdentity}.
 392          */
 393         @VisibleForTesting
 394         class SetPropertyJob extends WebOfTrustUpdateJob {
 395
 396                 /** The own identity to update properties on. */
 397                 private final OwnIdentity ownIdentity;
 398
 399                 /** The name of the property to update. */
 400                 private final String propertyName;
 401
 402                 /** The value of the property to set. */
 403                 private final String propertyValue;
 404
 405                 /**
 406                  * Creates a new set-property job.
 407                  *
 408                  * @param ownIdentity
 409                  *              The own identity to set the property on
 410                  * @param propertyName
 411                  *              The name of the property to set
 412                  * @param propertyValue
 413                  *              The value of the property to set
 414                  */
 415                 public SetPropertyJob(OwnIdentity ownIdentity, String propertyName, String propertyValue) {
 416                         this.ownIdentity = ownIdentity;
 417                         this.propertyName = propertyName;
 418                         this.propertyValue = propertyValue;
 419                 }
 420
 421                 /** {@inheritDoc} */
 422                 @Override
 423                 @SuppressWarnings("synthetic-access")
 424                 public void run() {
 425                         try {
 426                                 if (propertyValue == null) {
 427                                         webOfTrustConnector.removeProperty(ownIdentity, propertyName);
 428                                         ownIdentity.removeProperty(propertyName);
 429                                 } else {
 430                                         webOfTrustConnector.setProperty(ownIdentity, propertyName, propertyValue);
 431                                         ownIdentity.setProperty(propertyName, propertyValue);
 432                                 }
 433                                 finish(true);
 434                         } catch (PluginException pe1) {
 435                                 logger.log(Level.WARNING, String.format("Could not set Property “%2$s” to “%3$s” on Own Identity %1$s!", ownIdentity, propertyName, propertyValue), pe1);
 436                                 finish(false);
 437                         }
 438                 }
 439
 440                 //
 441                 // OBJECT METHODS
 442                 //
 443
 444                 /** {@inheritDoc} */
 445                 @Override
 446                 public boolean equals(Object object) {
 447                         if ((object == null) || !object.getClass().equals(getClass())) {
 448                                 return false;
 449                         }
 450                         SetPropertyJob updateJob = (SetPropertyJob) object;
 451                         return updateJob.ownIdentity.equals(ownIdentity) && updateJob.propertyName.equals(propertyName);
 452                 }
 453
 454                 /** {@inheritDoc} */
 455                 @Override
 456                 public int hashCode() {
 457                         return getClass().hashCode() ^ ownIdentity.hashCode() ^ propertyName.hashCode();
 458                 }
 459
 460                 /** {@inheritDoc} */
 461                 @Override
 462                 public String toString() {
 463                         return String.format("%s[ownIdentity=%s,propertyName=%s]", getClass().getSimpleName(), ownIdentity, propertyName);
 464                 }
 465
 466         }
 467
 468 }