X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fnet%2Fpterodactylus%2Fjsite%2Fcore%2FNodeManager.java;h=922a85a1ab78a5c6a49513d30c19121f4d3a7d97;hb=164c7174571672ca255b918a56c8db9336e31d19;hp=971d5c514ac11f29c72248873c83dbf087d6c224;hpb=fa2475af2c06ae03a4338a3fc1e327dc1970faf4;p=jSite2.git diff --git a/src/net/pterodactylus/jsite/core/NodeManager.java b/src/net/pterodactylus/jsite/core/NodeManager.java index 971d5c5..922a85a 100644 --- a/src/net/pterodactylus/jsite/core/NodeManager.java +++ b/src/net/pterodactylus/jsite/core/NodeManager.java @@ -19,6 +19,8 @@ package net.pterodactylus.jsite.core; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; @@ -29,27 +31,28 @@ import java.net.UnknownHostException; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; -import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Properties; -import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; import net.pterodactylus.fcp.highlevel.HighLevelClient; import net.pterodactylus.fcp.highlevel.HighLevelClientListener; +import net.pterodactylus.fcp.highlevel.HighLevelException; +import net.pterodactylus.fcp.highlevel.KeyGenerationResult; +import net.pterodactylus.jsite.util.IdGenerator; import net.pterodactylus.util.io.Closer; import net.pterodactylus.util.logging.Logging; +import net.pterodactylus.util.number.Hex; /** * TODO * * @author David ‘Bombe’ Roden <bombe@freenetproject.org> - * @version $Id$ */ -public class NodeManager implements Iterable, HighLevelClientListener { +public class NodeManager implements Iterable, PropertyChangeListener, HighLevelClientListener { /** Logger. */ private static final Logger logger = Logging.getLogger(NodeManager.class.getName()); @@ -69,12 +72,12 @@ public class NodeManager implements Iterable, HighLevelClientListener { /** All nodes. */ private List nodes = Collections.synchronizedList(new ArrayList()); + /** Map from node ID to node. */ + private Map idNodes = Collections.synchronizedMap(new HashMap()); + /** All FCP connections. */ private Map nodeClients = Collections.synchronizedMap(new HashMap()); - /** Keeps track of which connection is in use right now. */ - private Set usedConnections = Collections.synchronizedSet(new HashSet()); - /** Maps nodes to high-level clients. */ private Map clientNodes = Collections.synchronizedMap(new HashMap()); @@ -122,7 +125,8 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node that was added. */ private void fireNodeAdded(Node node) { - for (NodeListener nodeListener: nodeListeners) { + logger.log(Level.FINEST, "firing nodeAdded event with [node=" + node + "]"); + for (NodeListener nodeListener : nodeListeners) { nodeListener.nodeAdded(node); } } @@ -134,7 +138,8 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node that was removed */ private void fireNodeRemoved(Node node) { - for (NodeListener nodeListener: nodeListeners) { + logger.log(Level.FINEST, "firing nodeRemoved event with [node=" + node + "]"); + for (NodeListener nodeListener : nodeListeners) { nodeListener.nodeRemoved(node); } } @@ -146,12 +151,28 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node that is now connected */ private void fireNodeConnected(Node node) { - for (NodeListener nodeListener: nodeListeners) { + logger.log(Level.FINEST, "firing nodeConnected event with [node=" + node + "]"); + for (NodeListener nodeListener : nodeListeners) { nodeListener.nodeConnected(node); } } /** + * Notifies all listeners that a connection to a node has failed. + * + * @param node + * The node that could not be connected + * @param cause + * The cause of the failure + */ + private void fireNodeConnectionFailed(Node node, Throwable cause) { + logger.log(Level.FINEST, "firing nodeConnectionFailed event with [node=" + node + ",cause=" + cause + "]"); + for (NodeListener nodeListener : nodeListeners) { + nodeListener.nodeConnectionFailed(node, cause); + } + } + + /** * Notifies all listeners that the given node was disconnected. * * @param node @@ -161,7 +182,8 @@ public class NodeManager implements Iterable, HighLevelClientListener { * if there was no exception */ private void fireNodeDisconnected(Node node, Throwable throwable) { - for (NodeListener nodeListener: nodeListeners) { + logger.log(Level.FINEST, "firing nodeDisconnected event with [node=" + node + ",throwable=" + throwable + "]"); + for (NodeListener nodeListener : nodeListeners) { nodeListener.nodeDisconnected(node, throwable); } } @@ -209,6 +231,7 @@ public class NodeManager implements Iterable, HighLevelClientListener { * if an I/O error occurs loading the nodes */ public void load() throws IOException { + logger.log(Level.FINEST, "load()"); File directoryFile = new File(directory); File nodeFile = new File(directoryFile, "nodes.properties"); if (!nodeFile.exists() || !nodeFile.isFile() || !nodeFile.canRead()) { @@ -226,6 +249,10 @@ public class NodeManager implements Iterable, HighLevelClientListener { List loadedNodes = new ArrayList(); while (nodeProperties.containsKey("nodes." + ++nodeIndex + ".name")) { String nodePrefix = "nodes." + nodeIndex; + String nodeId = nodeProperties.getProperty(nodePrefix + ".id"); + if (nodeId == null) { + nodeId = Hex.toHex(IdGenerator.generateId()); + } String nodeName = nodeProperties.getProperty(nodePrefix + ".name"); if (!Verifier.verifyNodeName(nodeName)) { logger.log(Level.WARNING, "invalid node name “" + nodeName + "”, skipping…"); @@ -250,15 +277,16 @@ public class NodeManager implements Iterable, HighLevelClientListener { continue; } Node newNode = new Node(); + newNode.setId(nodeId); newNode.setName(nodeName); newNode.setHostname(nodeHostname); newNode.setPort(nodePort); loadedNodes.add(newNode); } - logger.fine("loaded " + loadedNodes.size() + " nodes from config"); + logger.log(Level.FINE, "loaded " + loadedNodes.size() + " nodes from config"); synchronized (syncObject) { nodes.clear(); - for (Node node: nodes) { + for (Node node : loadedNodes) { addNode(node); } } @@ -271,6 +299,7 @@ public class NodeManager implements Iterable, HighLevelClientListener { * if an I/O error occurs saving the nodes */ public void save() throws IOException { + logger.log(Level.FINEST, "save()"); File directoryFile = new File(directory); if (!directoryFile.exists()) { if (!directoryFile.mkdirs()) { @@ -279,8 +308,9 @@ public class NodeManager implements Iterable, HighLevelClientListener { } Properties nodeProperties = new Properties(); int nodeIndex = -1; - for (Node node: nodes) { + for (Node node : nodes) { String nodePrefix = "nodes." + ++nodeIndex; + nodeProperties.setProperty(nodePrefix + ".id", node.getId()); nodeProperties.setProperty(nodePrefix + ".name", node.getName()); nodeProperties.setProperty(nodePrefix + ".hostname", node.getHostname()); nodeProperties.setProperty(nodePrefix + ".port", String.valueOf(node.getPort())); @@ -301,20 +331,24 @@ public class NodeManager implements Iterable, HighLevelClientListener { * @see #connect(Node) * @param node * The node to connect to - * @throws UnknownHostException - * if the hostname of the node can not be resolved + * @return true if the node was added, false + * if the node was not added because it was already known */ - public void addNode(Node node) throws UnknownHostException { - synchronized (syncObject) { - if (!nodes.contains(node)) { - HighLevelClient highLevelClient= new HighLevelClient(clientName, node.getHostname(), node.getPort()); - nodes.add(node); - clientNodes.put(highLevelClient, node); - nodeClients.put(node, highLevelClient); - highLevelClient.addHighLevelClientListener(this); - fireNodeAdded(node); - } + public boolean addNode(Node node) { + logger.log(Level.FINEST, "addNode(node=" + node + ")"); + if (nodes.contains(node)) { + logger.log(Level.WARNING, "was told to add already known node: " + node); + return false; } + node.addPropertyChangeListener(this); + HighLevelClient highLevelClient = new HighLevelClient(clientName); + nodes.add(node); + idNodes.put(node.getId(), node); + clientNodes.put(highLevelClient, node); + nodeClients.put(node, highLevelClient); + highLevelClient.addHighLevelClientListener(this); + fireNodeAdded(node); + return true; } /** @@ -325,6 +359,7 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node to remove */ public void removeNode(Node node) { + logger.log(Level.FINEST, "removeNode(node=" + node + ")"); synchronized (syncObject) { if (!nodes.contains(node)) { return; @@ -332,6 +367,9 @@ public class NodeManager implements Iterable, HighLevelClientListener { if (nodeClients.containsKey(node)) { disconnect(node); } + nodes.remove(node); + idNodes.remove(node.getId()); + node.removePropertyChangeListener(this); fireNodeRemoved(node); } } @@ -343,14 +381,19 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node to connect to */ public void connect(Node node) { + logger.log(Level.FINEST, "connect(node=" + node + ")"); HighLevelClient highLevelClient; - synchronized (syncObject) { - highLevelClient = nodeClients.get(node); + highLevelClient = nodeClients.get(node); + if (highLevelClient == null) { + logger.log(Level.WARNING, "was told to connect to unknown node: " + node); + return; } try { - highLevelClient.connect(); + highLevelClient.connect(node.getHostname(), node.getPort()); + } catch (UnknownHostException uhe1) { + fireNodeConnectionFailed(node, uhe1); } catch (IOException ioe1) { - fireNodeDisconnected(node, ioe1); + fireNodeConnectionFailed(node, ioe1); } } @@ -361,6 +404,7 @@ public class NodeManager implements Iterable, HighLevelClientListener { * The node to disconnect */ public void disconnect(Node node) { + logger.log(Level.FINEST, "disconnect(node=" + node + ")"); synchronized (syncObject) { if (!nodes.contains(node)) { return; @@ -380,104 +424,74 @@ public class NodeManager implements Iterable, HighLevelClientListener { } /** - * “Borrows” a high-level client for the given node. A borrowed client - * has to be returned to the node manager using - * {@link #returnHighLevelClient(HighLevelClient)} when it is no longer in - * use, i.e. after a message has been sent! This method will block until a - * high-level client for the given node is available. + * Returns the high-level client for a given node. * * @param node * The node to get a high-level client for * @return The high-level client for a node, or null if the * node was disconnected or removed */ - public HighLevelClient borrowHighLevelClient(Node node) { - synchronized (syncObject) { - if (!nodeClients.containsKey(node)) { - return null; - } - HighLevelClient highLevelClient = nodeClients.get(node); - while (nodeClients.containsKey(node) && usedConnections.contains(highLevelClient)) { - try { - syncObject.wait(); - } catch (InterruptedException ie1) { - /* ignore. TODO - check. */ - } - } - if (!nodeClients.containsKey(node)) { - return null; - } - usedConnections.add(highLevelClient); - return highLevelClient; - } + public HighLevelClient getHighLevelClient(Node node) { + return nodeClients.get(node); } /** - * Returns a borrowed high-level client. + * Returns the node for a high-level client. * - * @see #borrowHighLevelClient(Node) * @param highLevelClient - * The high-level client to return + * The high-level client to get the node for + * @return The node for the high-level client, or null if the + * high-level client is not known */ - public void returnHighLevelClient(HighLevelClient highLevelClient) { - synchronized (syncObject) { - if (!clientNodes.containsKey(highLevelClient)) { - return; - } - usedConnections.remove(highLevelClient); - syncObject.notifyAll(); - } + public Node getNode(HighLevelClient highLevelClient) { + return clientNodes.get(highLevelClient); } - // - // PRIVATE METHODS - // + /** + * Returns the node identified by the given ID. + * + * @param id + * The ID of the node + * @return The node with the given ID, or null if no such + * node was found + */ + Node getNode(String id) { + return idNodes.get(id); + } /** - * Finds a currently unused high-level client, optionally waiting until a - * client is free and marking it used. + * Generates a new SSK key pair. * - * @param wait - * true to wait for a free connection, - * false to return null - * @param markAsUsed - * true to mark the connection as used before - * returning it, false not to mark it - * @return An unused FCP connection, or null if no connection - * could be found + * @return An array with the private key at index 0 and the + * public key at index 1 + * @throws IOException + * if an I/O error occurs communicating with the node + * @throws JSiteException + * if there is a problem with the node */ - @SuppressWarnings("unused") - private HighLevelClient findUnusedClient(boolean wait, boolean markAsUsed) { - synchronized (syncObject) { - HighLevelClient freeHighLevelClient = null; - while (freeHighLevelClient == null) { - for (HighLevelClient highLevelClient: nodeClients.values()) { - if (!usedConnections.contains(highLevelClient)) { - freeHighLevelClient = highLevelClient; - break; - } - } - if (freeHighLevelClient != null) { - if (markAsUsed) { - usedConnections.add(freeHighLevelClient); - } - return freeHighLevelClient; - } - if (!wait) { - return null; - } - try { - syncObject.wait(); - } catch (InterruptedException e) { - /* ignore, just re-check. */ - } - } - /* we never get here, but the compiler doesn't realize. */ - return null; + public String[] generateKeyPair() throws IOException, JSiteException { + logger.log(Level.FINEST, "generateKeyPair()"); + if (nodes.isEmpty()) { + throw new NoNodeException("no node configured"); } + Node node = nodes.get(0); + HighLevelClient highLevelClient = nodeClients.get(node); + try { + KeyGenerationResult keyGenerationResult = highLevelClient.generateKey().getResult(); + return new String[] { keyGenerationResult.getInsertURI(), keyGenerationResult.getRequestURI() }; + } catch (HighLevelException hle1) { + throw new BackendException(hle1); + } catch (InterruptedException e) { + /* ignore. */ + } + return null; } // + // PRIVATE METHODS + // + + // // INTERFACE HighLevelClientListener // @@ -485,7 +499,7 @@ public class NodeManager implements Iterable, HighLevelClientListener { * {@inheritDoc} */ public void clientConnected(HighLevelClient highLevelClient) { - logger.log(Level.FINER, "clientConnected(c=" + highLevelClient + ")"); + logger.log(Level.FINEST, "clientConnected(highLevelClient=" + highLevelClient + ")"); Node node = clientNodes.get(highLevelClient); if (node == null) { logger.log(Level.WARNING, "got event for unknown client"); @@ -498,17 +512,47 @@ public class NodeManager implements Iterable, HighLevelClientListener { * {@inheritDoc} */ public void clientDisconnected(HighLevelClient highLevelClient, Throwable throwable) { - logger.log(Level.FINER, "clientDisconnected(c=" + highLevelClient + ",t=" + throwable + ")"); + logger.log(Level.FINEST, "clientDisconnected(highLevelClient=" + highLevelClient + ",throwable=" + throwable + ")"); synchronized (syncObject) { - Node node = clientNodes.remove(highLevelClient); + Node node = clientNodes.get(highLevelClient); if (node == null) { logger.log(Level.WARNING, "got event for unknown client"); return; } - nodeClients.remove(node); - usedConnections.remove(highLevelClient); fireNodeDisconnected(node, throwable); } } + // + // INTERFACE PropertyChangeListener + // + + /** + * {@inheritDoc} + */ + public void propertyChange(PropertyChangeEvent propertyChangeEvent) { + Object eventSource = propertyChangeEvent.getSource(); + if (eventSource instanceof Node) { + String propertyName = propertyChangeEvent.getPropertyName(); + if ("hostname".equals(propertyName) || "port".equals(propertyName)) { + Node node = (Node) eventSource; + HighLevelClient highLevelClient = nodeClients.get(node); + if (highLevelClient == null) { + logger.log(Level.WARNING, "got property change event for unknown node: " + node); + return; + } + if (highLevelClient.isConnected()) { + highLevelClient.disconnect(); + try { + highLevelClient.connect(node.getHostname(), node.getPort()); + } catch (UnknownHostException uhe1) { + fireNodeConnectionFailed(node, uhe1); + } catch (IOException ioe1) { + fireNodeConnectionFailed(node, ioe1); + } + } + } + } + } + }