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

   1 /*
   2  * Sone - WebOfTrustConnector.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.HashMap;
  21 import java.util.HashSet;
  22 import java.util.Map;
  23 import java.util.Set;
  24 import java.util.logging.Level;
  25 import java.util.logging.Logger;
  26
  27 import net.pterodactylus.util.logging.Logging;
  28 import net.pterodactylus.util.number.Numbers;
  29 import net.pterodactylus.wotns.freenet.plugin.ConnectorListener;
  30 import net.pterodactylus.wotns.freenet.plugin.PluginConnector;
  31 import net.pterodactylus.wotns.freenet.plugin.PluginException;
  32 import freenet.support.SimpleFieldSet;
  33 import freenet.support.api.Bucket;
  34
  35 /**
  36  * Connector for the Web of Trust plugin.
  37  *
  38  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  39  */
  40 public class WebOfTrustConnector implements ConnectorListener {
  41
  42         /** The logger. */
  43         private static final Logger logger = Logging.getLogger(WebOfTrustConnector.class);
  44
  45         /** The name of the WoT plugin. */
  46         private static final String WOT_PLUGIN_NAME = "plugins.WebOfTrust.WebOfTrust";
  47
  48         /** A random connection identifier. */
  49         private static final String PLUGIN_CONNECTION_IDENTIFIER = "WoTNS-WoT-Connector-" + Math.abs(Math.random());
  50
  51         /** The current reply. */
  52         private Reply reply;
  53
  54         /** The plugin connector. */
  55         private final PluginConnector pluginConnector;
  56
  57         /**
  58          * Creates a new Web of Trust connector that uses the given plugin
  59          * connector.
  60          *
  61          * @param pluginConnector
  62          *            The plugin connector
  63          */
  64         public WebOfTrustConnector(PluginConnector pluginConnector) {
  65                 this.pluginConnector = pluginConnector;
  66                 pluginConnector.addConnectorListener(WOT_PLUGIN_NAME, PLUGIN_CONNECTION_IDENTIFIER, this);
  67         }
  68
  69         //
  70         // ACTIONS
  71         //
  72
  73         /**
  74          * Stops the web of trust connector and disconnects from the plugin
  75          * connector.
  76          */
  77         public void stop() {
  78                 pluginConnector.removeConnectorListener(WOT_PLUGIN_NAME, PLUGIN_CONNECTION_IDENTIFIER, this);
  79         }
  80
  81         /**
  82          * Loads all own identities from the Web of Trust plugin.
  83          *
  84          * @return All own identity
  85          * @throws WebOfTrustException
  86          *             if the own identities can not be loaded
  87          */
  88         public Set<OwnIdentity> loadAllOwnIdentities() throws WebOfTrustException {
  89                 @SuppressWarnings("hiding")
  90                 Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetOwnIdentities").get());
  91                 SimpleFieldSet fields = reply.getFields();
  92                 int ownIdentityCounter = -1;
  93                 Set<OwnIdentity> ownIdentities = new HashSet<OwnIdentity>();
  94                 while (true) {
  95                         String id = fields.get("Identity" + ++ownIdentityCounter);
  96                         if (id == null) {
  97                                 break;
  98                         }
  99                         String requestUri = fields.get("RequestURI" + ownIdentityCounter);
 100                         String insertUri = fields.get("InsertURI" + ownIdentityCounter);
 101                         String nickname = fields.get("Nickname" + ownIdentityCounter);
 102                         DefaultOwnIdentity ownIdentity = new DefaultOwnIdentity(this, id, nickname, requestUri, insertUri);
 103                         ownIdentity.setContextsPrivate(parseContexts("Contexts" + ownIdentityCounter + ".", fields));
 104                         ownIdentity.setPropertiesPrivate(parseProperties("Properties" + ownIdentityCounter + ".", fields));
 105                         ownIdentities.add(ownIdentity);
 106                 }
 107                 return ownIdentities;
 108         }
 109
 110         /**
 111          * Loads all identities that the given identities trusts with a score of
 112          * more than 0.
 113          *
 114          * @param ownIdentity
 115          *            The own identity
 116          * @return All trusted identities
 117          * @throws WebOfTrustException
 118          *             if an error occured talking to the Web of Trust plugin
 119          */
 120         public Set<Identity> loadTrustedIdentities(OwnIdentity ownIdentity) throws WebOfTrustException {
 121                 return loadTrustedIdentities(ownIdentity, null);
 122         }
 123
 124         /**
 125          * Loads all identities that the given identities trusts with a score of
 126          * more than 0 and the (optional) given context.
 127          *
 128          * @param ownIdentity
 129          *            The own identity
 130          * @param context
 131          *            The context to filter, or {@code null}
 132          * @return All trusted identities
 133          * @throws WebOfTrustException
 134          *             if an error occured talking to the Web of Trust plugin
 135          */
 136         public Set<Identity> loadTrustedIdentities(OwnIdentity ownIdentity, String context) throws WebOfTrustException {
 137                 @SuppressWarnings("hiding")
 138                 Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetIdentitiesByScore").put("TreeOwner", ownIdentity.getId()).put("Selection", "+").put("Context", (context == null) ? "" : context).get());
 139                 SimpleFieldSet fields = reply.getFields();
 140                 Set<Identity> identities = new HashSet<Identity>();
 141                 int identityCounter = -1;
 142                 while (true) {
 143                         String id = fields.get("Identity" + ++identityCounter);
 144                         if (id == null) {
 145                                 break;
 146                         }
 147                         String nickname = fields.get("Nickname" + identityCounter);
 148                         String requestUri = fields.get("RequestURI" + identityCounter);
 149                         DefaultIdentity identity = new DefaultIdentity(this, id, nickname, requestUri);
 150                         identity.setContextsPrivate(parseContexts("Contexts" + identityCounter + ".", fields));
 151                         identity.setPropertiesPrivate(parseProperties("Properties" + identityCounter + ".", fields));
 152                         identity.setTrustPrivate(ownIdentity, new Trust(Numbers.safeParseInteger(fields.get("Trust" + identityCounter)), Numbers.safeParseInteger(fields.get("Score" + identityCounter)), Numbers.safeParseInteger(fields.get("Rank" + identityCounter))));
 153                         identities.add(identity);
 154                 }
 155                 return identities;
 156         }
 157
 158         /**
 159          * Adds the given context to the given identity.
 160          *
 161          * @param ownIdentity
 162          *            The identity to add the context to
 163          * @param context
 164          *            The context to add
 165          * @throws PluginException
 166          *             if an error occured talking to the Web of Trust plugin
 167          */
 168         public void addContext(OwnIdentity ownIdentity, String context) throws PluginException {
 169                 performRequest(SimpleFieldSetConstructor.create().put("Message", "AddContext").put("Identity", ownIdentity.getId()).put("Context", context).get());
 170         }
 171
 172         /**
 173          * Removes the given context from the given identity.
 174          *
 175          * @param ownIdentity
 176          *            The identity to remove the context from
 177          * @param context
 178          *            The context to remove
 179          * @throws PluginException
 180          *             if an error occured talking to the Web of Trust plugin
 181          */
 182         public void removeContext(OwnIdentity ownIdentity, String context) throws PluginException {
 183                 performRequest(SimpleFieldSetConstructor.create().put("Message", "RemoveContext").put("Identity", ownIdentity.getId()).put("Context", context).get());
 184         }
 185
 186         /**
 187          * Returns the value of the property with the given name.
 188          *
 189          * @param identity
 190          *            The identity whose properties to check
 191          * @param name
 192          *            The name of the property to return
 193          * @return The value of the property, or {@code null} if there is no value
 194          * @throws PluginException
 195          *             if an error occured talking to the Web of Trust plugin
 196          */
 197         public String getProperty(Identity identity, String name) throws PluginException {
 198                 @SuppressWarnings("hiding")
 199                 Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetProperty").put("Identity", identity.getId()).put("Property", name).get());
 200                 return reply.getFields().get("Property");
 201         }
 202
 203         /**
 204          * Sets the property with the given name to the given value.
 205          *
 206          * @param ownIdentity
 207          *            The identity to set the property on
 208          * @param name
 209          *            The name of the property to set
 210          * @param value
 211          *            The value to set
 212          * @throws PluginException
 213          *             if an error occured talking to the Web of Trust plugin
 214          */
 215         public void setProperty(OwnIdentity ownIdentity, String name, String value) throws PluginException {
 216                 performRequest(SimpleFieldSetConstructor.create().put("Message", "SetProperty").put("Identity", ownIdentity.getId()).put("Property", name).put("Value", value).get());
 217         }
 218
 219         /**
 220          * Removes the property with the given name.
 221          *
 222          * @param ownIdentity
 223          *            The identity to remove the property from
 224          * @param name
 225          *            The name of the property to remove
 226          * @throws PluginException
 227          *             if an error occured talking to the Web of Trust plugin
 228          */
 229         public void removeProperty(OwnIdentity ownIdentity, String name) throws PluginException {
 230                 performRequest(SimpleFieldSetConstructor.create().put("Message", "RemoveProperty").put("Identity", ownIdentity.getId()).put("Property", name).get());
 231         }
 232
 233         /**
 234          * Returns the trust for the given identity assigned to it by the given own
 235          * identity.
 236          *
 237          * @param ownIdentity
 238          *            The own identity
 239          * @param identity
 240          *            The identity to get the trust for
 241          * @return The trust for the given identity
 242          * @throws PluginException
 243          *             if an error occured talking to the Web of Trust plugin
 244          */
 245         public Trust getTrust(OwnIdentity ownIdentity, Identity identity) throws PluginException {
 246                 Reply getTrustReply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetIdentity").put("Truster", ownIdentity.getId()).put("Identity", identity.getId()).get());
 247                 String trust = getTrustReply.getFields().get("Trust");
 248                 String score = getTrustReply.getFields().get("Score");
 249                 String rank = getTrustReply.getFields().get("Rank");
 250                 Integer explicit = null;
 251                 Integer implicit = null;
 252                 Integer distance = null;
 253                 try {
 254                         explicit = Integer.valueOf(trust);
 255                 } catch (NumberFormatException nfe1) {
 256                         /* ignore. */
 257                 }
 258                 try {
 259                         implicit = Integer.valueOf(score);
 260                         distance = Integer.valueOf(rank);
 261                 } catch (NumberFormatException nfe1) {
 262                         /* ignore. */
 263                 }
 264                 return new Trust(explicit, implicit, distance);
 265         }
 266
 267         /**
 268          * Sets the trust for the given identity.
 269          *
 270          * @param ownIdentity
 271          *            The trusting identity
 272          * @param identity
 273          *            The trusted identity
 274          * @param trust
 275          *            The amount of trust (-100 thru 100)
 276          * @param comment
 277          *            The comment or explanation of the trust value
 278          * @throws PluginException
 279          *             if an error occured talking to the Web of Trust plugin
 280          */
 281         public void setTrust(OwnIdentity ownIdentity, Identity identity, int trust, String comment) throws PluginException {
 282                 performRequest(SimpleFieldSetConstructor.create().put("Message", "SetTrust").put("Truster", ownIdentity.getId()).put("Trustee", identity.getId()).put("Value", String.valueOf(trust)).put("Comment", comment).get());
 283         }
 284
 285         /**
 286          * Removes any trust assignment of the given own identity for the given
 287          * identity.
 288          *
 289          * @param ownIdentity
 290          *            The own identity
 291          * @param identity
 292          *            The identity to remove all trust for
 293          * @throws WebOfTrustException
 294          *             if an error occurs
 295          */
 296         public void removeTrust(OwnIdentity ownIdentity, Identity identity) throws WebOfTrustException {
 297                 performRequest(SimpleFieldSetConstructor.create().put("Message", "RemoveTrust").put("Truster", ownIdentity.getId()).put("Trustee", identity.getId()).get());
 298         }
 299
 300         /**
 301          * Pings the Web of Trust plugin. If the plugin can not be reached, a
 302          * {@link PluginException} is thrown.
 303          *
 304          * @throws PluginException
 305          *             if the plugin is not loaded
 306          */
 307         public void ping() throws PluginException {
 308                 performRequest(SimpleFieldSetConstructor.create().put("Message", "Ping").get());
 309         }
 310
 311         //
 312         // PRIVATE ACTIONS
 313         //
 314
 315         /**
 316          * Parses the contexts from the given fields.
 317          *
 318          * @param prefix
 319          *            The prefix to use to access the contexts
 320          * @param fields
 321          *            The fields to parse the contexts from
 322          * @return The parsed contexts
 323          */
 324         private Set<String> parseContexts(String prefix, SimpleFieldSet fields) {
 325                 Set<String> contexts = new HashSet<String>();
 326                 int contextCounter = -1;
 327                 while (true) {
 328                         String context = fields.get(prefix + "Context" + ++contextCounter);
 329                         if (context == null) {
 330                                 break;
 331                         }
 332                         contexts.add(context);
 333                 }
 334                 return contexts;
 335         }
 336
 337         /**
 338          * Parses the properties from the given fields.
 339          *
 340          * @param prefix
 341          *            The prefix to use to access the properties
 342          * @param fields
 343          *            The fields to parse the properties from
 344          * @return The parsed properties
 345          */
 346         private Map<String, String> parseProperties(String prefix, SimpleFieldSet fields) {
 347                 Map<String, String> properties = new HashMap<String, String>();
 348                 int propertiesCounter = -1;
 349                 while (true) {
 350                         String propertyName = fields.get(prefix + "Property" + ++propertiesCounter + ".Name");
 351                         if (propertyName == null) {
 352                                 break;
 353                         }
 354                         String propertyValue = fields.get(prefix + "Property" + propertiesCounter + ".Value");
 355                         properties.put(propertyName, propertyValue);
 356                 }
 357                 return properties;
 358         }
 359
 360         /**
 361          * Sends a request containing the given fields and waits for the target
 362          * message.
 363          *
 364          * @param fields
 365          *            The fields of the message
 366          * @return The reply message
 367          * @throws PluginException
 368          *             if the request could not be sent
 369          */
 370         private Reply performRequest(SimpleFieldSet fields) throws PluginException {
 371                 return performRequest(fields, null);
 372         }
 373
 374         /**
 375          * Sends a request containing the given fields and waits for the target
 376          * message.
 377          *
 378          * @param fields
 379          *            The fields of the message
 380          * @param data
 381          *            The payload of the message
 382          * @return The reply message
 383          * @throws PluginException
 384          *             if the request could not be sent
 385          */
 386         private synchronized Reply performRequest(SimpleFieldSet fields, Bucket data) throws PluginException {
 387                 reply = new Reply();
 388                 logger.log(Level.FINE, "Sending FCP Request: " + fields.get("Message"));
 389                 synchronized (reply) {
 390                         pluginConnector.sendRequest(WOT_PLUGIN_NAME, PLUGIN_CONNECTION_IDENTIFIER, fields, data);
 391                         try {
 392                                 reply.wait();
 393                         } catch (InterruptedException ie1) {
 394                                 logger.log(Level.WARNING, "Got interrupted while waiting for reply on " + fields.get("Message") + ".", ie1);
 395                         }
 396                 }
 397                 logger.log(Level.FINEST, "Received FCP Response for %s: %s", new Object[] { fields.get("Message"), (reply.getFields() != null) ? reply.getFields().get("Message") : null });
 398                 if ((reply.getFields() == null) || "Error".equals(reply.getFields().get("Message"))) {
 399                         throw new PluginException("Could not perform request for " + fields.get("Message"));
 400                 }
 401                 return reply;
 402         }
 403
 404         //
 405         // INTERFACE ConnectorListener
 406         //
 407
 408         /**
 409          * {@inheritDoc}
 410          */
 411         @Override
 412         public void receivedReply(@SuppressWarnings("hiding") PluginConnector pluginConnector, SimpleFieldSet fields, Bucket data) {
 413                 String messageName = fields.get("Message");
 414                 logger.log(Level.FINEST, "Received Reply from Plugin: " + messageName);
 415                 synchronized (reply) {
 416                         reply.setFields(fields);
 417                         reply.setData(data);
 418                         reply.notify();
 419                 }
 420         }
 421
 422         /**
 423          * Container for the data of the reply from a plugin.
 424          *
 425          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 426          */
 427         private static class Reply {
 428
 429                 /** The fields of the reply. */
 430                 private SimpleFieldSet fields;
 431
 432                 /** The payload of the reply. */
 433                 private Bucket data;
 434
 435                 /** Empty constructor. */
 436                 public Reply() {
 437                         /* do nothing. */
 438                 }
 439
 440                 /**
 441                  * Returns the fields of the reply.
 442                  *
 443                  * @return The fields of the reply
 444                  */
 445                 public SimpleFieldSet getFields() {
 446                         return fields;
 447                 }
 448
 449                 /**
 450                  * Sets the fields of the reply.
 451                  *
 452                  * @param fields
 453                  *            The fields of the reply
 454                  */
 455                 public void setFields(SimpleFieldSet fields) {
 456                         this.fields = fields;
 457                 }
 458
 459                 /**
 460                  * Returns the payload of the reply.
 461                  *
 462                  * @return The payload of the reply (may be {@code null})
 463                  */
 464                 @SuppressWarnings("unused")
 465                 public Bucket getData() {
 466                         return data;
 467                 }
 468
 469                 /**
 470                  * Sets the payload of the reply.
 471                  *
 472                  * @param data
 473                  *            The payload of the reply (may be {@code null})
 474                  */
 475                 public void setData(Bucket data) {
 476                         this.data = data;
 477                 }
 478
 479         }
 480
 481         /**
 482          * Helper method to create {@link SimpleFieldSet}s with terser code.
 483          *
 484          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 485          */
 486         private static class SimpleFieldSetConstructor {
 487
 488                 /** The field set being created. */
 489                 private SimpleFieldSet simpleFieldSet;
 490
 491                 /**
 492                  * Creates a new simple field set constructor.
 493                  *
 494                  * @param shortLived
 495                  *            {@code true} if the resulting simple field set should be
 496                  *            short-lived, {@code false} otherwise
 497                  */
 498                 private SimpleFieldSetConstructor(boolean shortLived) {
 499                         simpleFieldSet = new SimpleFieldSet(shortLived);
 500                 }
 501
 502                 //
 503                 // ACCESSORS
 504                 //
 505
 506                 /**
 507                  * Returns the created simple field set.
 508                  *
 509                  * @return The created simple field set
 510                  */
 511                 public SimpleFieldSet get() {
 512                         return simpleFieldSet;
 513                 }
 514
 515                 /**
 516                  * Sets the field with the given name to the given value.
 517                  *
 518                  * @param name
 519                  *            The name of the fleld
 520                  * @param value
 521                  *            The value of the field
 522                  * @return This constructor (for method chaining)
 523                  */
 524                 public SimpleFieldSetConstructor put(String name, String value) {
 525                         simpleFieldSet.putOverwrite(name, value);
 526                         return this;
 527                 }
 528
 529                 //
 530                 // ACTIONS
 531                 //
 532
 533                 /**
 534                  * Creates a new simple field set constructor.
 535                  *
 536                  * @return The created simple field set constructor
 537                  */
 538                 public static SimpleFieldSetConstructor create() {
 539                         return create(true);
 540                 }
 541
 542                 /**
 543                  * Creates a new simple field set constructor.
 544                  *
 545                  * @param shortLived
 546                  *            {@code true} if the resulting simple field set should be
 547                  *            short-lived, {@code false} otherwise
 548                  * @return The created simple field set constructor
 549                  */
 550                 public static SimpleFieldSetConstructor create(boolean shortLived) {
 551                         SimpleFieldSetConstructor simpleFieldSetConstructor = new SimpleFieldSetConstructor(shortLived);
 552                         return simpleFieldSetConstructor;
 553                 }
 554
 555         }
 556
 557 }