X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Ffreenet%2Fwot%2FWebOfTrustConnector.java;h=a8806c105eecddf308468c9fe9f6a9e7c0fad400;hb=470ae9420753b23119c103976f5cf060e3cdcd08;hp=65b7ce877425379fd8938f3928d8dd30191549f2;hpb=5ac1da7c51270ade6171b9755cc26c9b2385c426;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 65b7ce8..a8806c1 100644 --- a/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java +++ b/src/main/java/net/pterodactylus/sone/freenet/wot/WebOfTrustConnector.java @@ -75,7 +75,7 @@ public class WebOfTrustConnector implements ConnectorListener { * if the own identities can not be loaded */ public Set loadAllOwnIdentities() throws PluginException { - Reply reply = performRequest("OwnIdentities", SimpleFieldSetConstructor.create().put("Message", "GetOwnIdentities").get()); + Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetOwnIdentities").get(), "OwnIdentities"); SimpleFieldSet fields = reply.getFields(); int ownIdentityCounter = -1; Set ownIdentities = new HashSet(); @@ -88,57 +88,245 @@ public class WebOfTrustConnector implements ConnectorListener { String insertUri = fields.get("InsertURI" + ownIdentityCounter); String nickname = fields.get("Nickname" + ownIdentityCounter); OwnIdentity ownIdentity = new OwnIdentity(id, nickname, requestUri, insertUri); + ownIdentity.setContexts(parseContexts("Contexts" + ownIdentityCounter, fields)); + ownIdentity.setProperties(parseProperties("Properties" + ownIdentityCounter, fields)); ownIdentities.add(ownIdentity); } return ownIdentities; } + /** + * 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 + * The own identity + * @param context + * The context to filter, or {@code null} + * @return All trusted identities + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public Set loadTrustedIdentities(OwnIdentity ownIdentity, String context) throws PluginException { + Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetIdentitiesByScore").put("TreeOwner", ownIdentity.getId()).put("Selection", "+").put("Context", (context == null) ? "" : context).get(), "Identities"); + SimpleFieldSet fields = reply.getFields(); + Set identities = new HashSet(); + int identityCounter = -1; + while (true) { + String id = fields.get("Identity" + ++identityCounter); + if (id == null) { + break; + } + String nickname = fields.get("Nickname" + identityCounter); + String requestUri = fields.get("RequestURI" + identityCounter); + Identity identity = new Identity(id, nickname, requestUri); + identity.setContexts(parseContexts("Contexts" + identityCounter, fields)); + identity.setProperties(parseProperties("Properties" + identityCounter, fields)); + identities.add(identity); + } + return identities; + } + + /** + * Adds the given context to the given identity. + * + * @param ownIdentity + * The identity to add the context to + * @param context + * The context to add + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public void addContext(OwnIdentity ownIdentity, String context) throws PluginException { + performRequest(SimpleFieldSetConstructor.create().put("Message", "AddContext").put("Identity", ownIdentity.getId()).put("Context", context).get(), "ContextAdded"); + } + + /** + * Removes the given context from the given identity. + * + * @param ownIdentity + * The identity to remove the context from + * @param context + * The context to remove + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public void removeContext(OwnIdentity ownIdentity, String context) throws PluginException { + performRequest(SimpleFieldSetConstructor.create().put("Message", "RemoveContext").put("Identity", ownIdentity.getId()).put("Context", context).get(), "ContextRemoved"); + } + + /** + * Returns the value of the property with the given name. + * + * @param identity + * The identity whose properties to check + * @param name + * The name of the property to return + * @return The value of the property, or {@code null} if there is no value + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public String getProperty(Identity identity, String name) throws PluginException { + Reply reply = performRequest(SimpleFieldSetConstructor.create().put("Message", "GetProperty").put("Identity", identity.getId()).put("Property", name).get(), "PropertyValue"); + return reply.getFields().get("Property"); + } + + /** + * Sets the property with the given name to the given value. + * + * @param ownIdentity + * The identity to set the property on + * @param name + * The name of the property to set + * @param value + * The value to set + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public void setProperty(OwnIdentity ownIdentity, String name, String value) throws PluginException { + performRequest(SimpleFieldSetConstructor.create().put("Message", "SetProperty").put("Identity", ownIdentity.getId()).put("Property", name).put("Value", value).get(), "PropertyAdded"); + } + + /** + * Removes the property with the given name. + * + * @param ownIdentity + * The identity to remove the property from + * @param name + * The name of the property to remove + * @throws PluginException + * if an error occured talking to the Web of Trust plugin + */ + public void removeProperty(OwnIdentity ownIdentity, String name) throws PluginException { + performRequest(SimpleFieldSetConstructor.create().put("Message", "RemoveProperty").put("Identity", ownIdentity.getId()).put("Property", name).get(), "PropertyRemoved"); + } + + /** + * Pings the Web of Trust plugin. If the plugin can not be reached, a + * {@link PluginException} is thrown. + * + * @throws PluginException + * if the plugin is not loaded + */ + public void ping() throws PluginException { + performRequest(SimpleFieldSetConstructor.create().put("Message", "Ping").get(), "Pong"); + } + // // PRIVATE ACTIONS // /** + * Parses the contexts from the given fields. + * + * @param prefix + * The prefix to use to access the contexts + * @param fields + * The fields to parse the contexts from + * @return The parsed contexts + */ + private Set parseContexts(String prefix, SimpleFieldSet fields) { + Set contexts = new HashSet(); + int contextCounter = -1; + while (true) { + String context = fields.get(prefix + "Context" + ++contextCounter); + if (context == null) { + break; + } + contexts.add(context); + } + return contexts; + } + + /** + * Parses the properties from the given fields. + * + * @param prefix + * The prefix to use to access the properties + * @param fields + * The fields to parse the properties from + * @return The parsed properties + */ + private Map parseProperties(String prefix, SimpleFieldSet fields) { + Map properties = new HashMap(); + int propertiesCounter = -1; + while (true) { + String propertyName = fields.get(prefix + "Property" + ++propertiesCounter + "Name"); + if (propertyName == null) { + break; + } + String propertyValue = fields.get(prefix + "Property" + propertiesCounter + "Value"); + properties.put(propertyName, propertyValue); + } + return properties; + } + + /** * Sends a request containing the given fields and waits for the target * message. * - * @param targetMessage - * The message of the reply to wait for * @param fields * The fields of the message + * @param targetMessages + * The messages of the reply to wait for * @return The reply message * @throws PluginException * if the request could not be sent */ - private Reply performRequest(String targetMessage, SimpleFieldSet fields) throws PluginException { - return performRequest(targetMessage, fields, null); + private Reply performRequest(SimpleFieldSet fields, String... targetMessages) throws PluginException { + return performRequest(fields, null, targetMessages); } /** * Sends a request containing the given fields and waits for the target * message. * - * @param targetMessage - * The message of the reply to wait for * @param fields * The fields of the message * @param data * The payload of the message + * @param targetMessages + * The messages of the reply to wait for * @return The reply message * @throws PluginException * if the request could not be sent */ - private Reply performRequest(String targetMessage, SimpleFieldSet fields, Bucket data) throws PluginException { + private Reply performRequest(SimpleFieldSet fields, Bucket data, String... targetMessages) throws PluginException { @SuppressWarnings("synthetic-access") Reply reply = new Reply(); - replies.put(targetMessage, reply); + for (String targetMessage : targetMessages) { + replies.put(targetMessage, reply); + } + replies.put("Error", reply); synchronized (reply) { pluginConnector.sendRequest(WOT_PLUGIN_NAME, PLUGIN_CONNECTION_IDENTIFIER, fields, data); try { - reply.wait(); + reply.wait(60000); } catch (InterruptedException ie1) { logger.log(Level.WARNING, "Got interrupted while waiting for reply on GetOwnIdentities.", ie1); } } + for (String targetMessage : targetMessages) { + replies.remove(targetMessage); + } + replies.remove("Error"); + if ((reply.getFields() != null) && reply.getFields().get("Message").equals("Error")) { + throw new PluginException("Could not perform request for " + targetMessages[0]); + } return reply; }