X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Ffreenet%2Fwot%2FWebOfTrustConnector.java;h=a1091360b94695cc166e8cb46070285571b2a1da;hb=554413c81f05801e09e8384b39e2e9f609cd4bc1;hp=531275d1bfd67fe0b90f9b37ae550f9efc46656e;hpb=4e0b3740e2fbb8c34db49a8d2c7a4dc9581988b1;p=Sone.git diff --git a/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java b/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java index 531275d..a109136 100644 --- a/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java +++ b/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java @@ -1,5 +1,5 @@ /* - * Sone - WebOfTrustConnector.java - Copyright © 2010–2012 David Roden + * Sone - WebOfTrustConnector.java - Copyright © 2010–2013 David Roden * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -25,11 +25,16 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.logging.Level; import java.util.logging.Logger; -import net.pterodactylus.sone.freenet.plugin.ConnectorListener; import net.pterodactylus.sone.freenet.plugin.PluginConnector; import net.pterodactylus.sone.freenet.plugin.PluginException; +import net.pterodactylus.sone.freenet.plugin.event.ReceivedReplyEvent; import net.pterodactylus.util.logging.Logging; import net.pterodactylus.util.number.Numbers; + +import com.google.common.collect.MapMaker; +import com.google.common.eventbus.Subscribe; +import com.google.inject.Inject; + import freenet.support.SimpleFieldSet; import freenet.support.api.Bucket; @@ -52,6 +57,9 @@ public class WebOfTrustConnector { /** The plugin connector. */ private final PluginConnector pluginConnector; + /** Map for replies. */ + private final Map replies = new MapMaker().makeMap(); + /** * Creates a new Web of Trust connector that uses the given plugin * connector. @@ -59,6 +67,7 @@ public class WebOfTrustConnector { * @param pluginConnector * The plugin connector */ + @Inject public WebOfTrustConnector(PluginConnector pluginConnector) { this.pluginConnector = pluginConnector; } @@ -104,20 +113,6 @@ public class WebOfTrustConnector { /** * Loads all identities that the given identities trusts with a score of - * more than 0. - * - * @param ownIdentity - * The own identity - * @return All trusted identities - * @throws PluginException - * if an error occured talking to the Web of Trust plugin - */ - public Set loadTrustedIdentities(OwnIdentity ownIdentity) throws PluginException { - return loadTrustedIdentities(ownIdentity, null); - } - - /** - * Loads all identities that the given identities trusts with a score of * more than 0 and the (optional) given context. * * @param ownIdentity @@ -144,8 +139,8 @@ public class WebOfTrustConnector { identity.setContexts(parseContexts("Contexts" + identityCounter + ".", fields)); identity.setProperties(parseProperties("Properties" + identityCounter + ".", fields)); Integer trust = Numbers.safeParseInteger(fields.get("Trust" + identityCounter), null); - int score = Numbers.safeParseInteger(fields.get("Score" + identityCounter)); - int rank = Numbers.safeParseInteger(fields.get("Rank" + identityCounter)); + int score = Numbers.safeParseInteger(fields.get("Score" + identityCounter), 0); + int rank = Numbers.safeParseInteger(fields.get("Rank" + identityCounter), 0); identity.setTrust(ownIdentity, new Trust(trust, score, rank)); identities.add(identity); } @@ -380,33 +375,26 @@ public class WebOfTrustConnector { * if the request could not be sent */ private Reply performRequest(SimpleFieldSet fields, Bucket data) throws PluginException { - final String identifier = "FCP-Command-" + System.currentTimeMillis() + "-" + counter.getAndIncrement(); - final Reply reply = new Reply(); + String identifier = "FCP-Command-" + System.currentTimeMillis() + "-" + counter.getAndIncrement(); + Reply reply = new Reply(); + PluginIdentifier pluginIdentifier = new PluginIdentifier(WOT_PLUGIN_NAME, identifier); + replies.put(pluginIdentifier, reply); + logger.log(Level.FINE, String.format("Sending FCP Request: %s", fields.get("Message"))); - ConnectorListener connectorListener = new ConnectorListener() { - - @Override - @SuppressWarnings("synthetic-access") - public void receivedReply(PluginConnector pluginConnector, SimpleFieldSet fields, Bucket data) { - String messageName = fields.get("Message"); - logger.log(Level.FINEST, String.format("Received Reply from Plugin: %s", messageName)); - synchronized (reply) { - reply.setFields(fields); - reply.setData(data); - reply.notify(); - } - } - }; - pluginConnector.addConnectorListener(WOT_PLUGIN_NAME, identifier, connectorListener); synchronized (reply) { - pluginConnector.sendRequest(WOT_PLUGIN_NAME, identifier, fields, data); try { - reply.wait(); - } catch (InterruptedException ie1) { - logger.log(Level.WARNING, String.format("Got interrupted while waiting for reply on %s.", fields.get("Message")), ie1); + pluginConnector.sendRequest(WOT_PLUGIN_NAME, identifier, fields, data); + while (reply.getFields() == null) { + try { + reply.wait(); + } catch (InterruptedException ie1) { + logger.log(Level.WARNING, String.format("Got interrupted while waiting for reply on %s.", fields.get("Message")), ie1); + } + } + } finally { + replies.remove(pluginIdentifier); } } - pluginConnector.removeConnectorListener(WOT_PLUGIN_NAME, identifier, connectorListener); logger.log(Level.FINEST, String.format("Received FCP Response for %s: %s", fields.get("Message"), (reply.getFields() != null) ? reply.getFields().get("Message") : null)); if ((reply.getFields() == null) || "Error".equals(reply.getFields().get("Message"))) { throw new PluginException("Could not perform request for " + fields.get("Message")); @@ -415,6 +403,27 @@ public class WebOfTrustConnector { } /** + * Notifies the connector that a plugin reply was received. + * + * @param receivedReplyEvent + * The event + */ + @Subscribe + public void receivedReply(ReceivedReplyEvent receivedReplyEvent) { + PluginIdentifier pluginIdentifier = new PluginIdentifier(receivedReplyEvent.pluginName(), receivedReplyEvent.identifier()); + Reply reply = replies.remove(pluginIdentifier); + if (reply == null) { + return; + } + logger.log(Level.FINEST, String.format("Received Reply from Plugin: %s", receivedReplyEvent.fieldSet().get("Message"))); + synchronized (reply) { + reply.setFields(receivedReplyEvent.fieldSet()); + reply.setData(receivedReplyEvent.data()); + reply.notify(); + } + } + + /** * Container for the data of the reply from a plugin. * * @author David ‘Bombe’ Roden @@ -549,4 +558,57 @@ public class WebOfTrustConnector { } + /** + * Container for identifying plugins. Plugins are identified by their plugin + * name and their unique identifier. + * + * @author David Roden + */ + private static class PluginIdentifier { + + /** The plugin name. */ + private final String pluginName; + + /** The plugin identifier. */ + private final String identifier; + + /** + * Creates a new plugin identifier. + * + * @param pluginName + * The name of the plugin + * @param identifier + * The identifier of the plugin + */ + public PluginIdentifier(String pluginName, String identifier) { + this.pluginName = pluginName; + this.identifier = identifier; + } + + // + // OBJECT METHODS + // + + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return pluginName.hashCode() ^ identifier.hashCode(); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean equals(Object object) { + if (!(object instanceof PluginIdentifier)) { + return false; + } + PluginIdentifier pluginIdentifier = (PluginIdentifier) object; + return pluginName.equals(pluginIdentifier.pluginName) && identifier.equals(pluginIdentifier.identifier); + } + + } + }