X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fnet%2Fpterodactylus%2Ffcp%2Fhighlevel%2FFcpClient.java;h=fdcdc39b32166ce921543614e2a94ba0c282dbf8;hb=d8cf32504b5c889235dd55991ccdae2e34ba5cfb;hp=bcf529b6dca4a14e26ffa5e4f57c0062ff11f581;hpb=6f8d718b2a9b274e8898ab964b355bf4b349a787;p=jFCPlib.git
diff --git a/src/net/pterodactylus/fcp/highlevel/FcpClient.java b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
index bcf529b..fdcdc39 100644
--- a/src/net/pterodactylus/fcp/highlevel/FcpClient.java
+++ b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
@@ -21,16 +21,30 @@ package net.pterodactylus.fcp.highlevel;
import java.io.IOException;
import java.net.InetAddress;
+import java.net.URL;
import java.net.UnknownHostException;
+import java.util.HashSet;
+import java.util.Set;
import java.util.concurrent.CountDownLatch;
+import net.pterodactylus.fcp.AddPeer;
import net.pterodactylus.fcp.ClientHello;
import net.pterodactylus.fcp.CloseConnectionDuplicateClientName;
+import net.pterodactylus.fcp.EndListPeers;
import net.pterodactylus.fcp.FcpAdapter;
import net.pterodactylus.fcp.FcpConnection;
import net.pterodactylus.fcp.FcpListener;
+import net.pterodactylus.fcp.ListPeerNotes;
+import net.pterodactylus.fcp.ListPeers;
+import net.pterodactylus.fcp.ModifyPeer;
import net.pterodactylus.fcp.NodeHello;
+import net.pterodactylus.fcp.NodeRef;
+import net.pterodactylus.fcp.Peer;
+import net.pterodactylus.fcp.PeerNote;
+import net.pterodactylus.fcp.PeerRemoved;
import net.pterodactylus.fcp.ProtocolError;
+import net.pterodactylus.fcp.RemovePeer;
+import net.pterodactylus.util.thread.ObjectWrapper;
/**
* High-level FCP client that hides the details of the underlying FCP
@@ -137,26 +151,22 @@ public class FcpClient {
* {@inheritDoc}
*/
@Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.connect();
+ ClientHello clientHello = new ClientHello(name);
+ fcpConnection.sendMessage(clientHello);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
public void receivedNodeHello(FcpConnection fcpConnection, NodeHello nodeHello) {
completionLatch.countDown();
}
};
- fcpConnection.addFcpListener(fcpListener);
- fcpConnection.connect();
- ClientHello clientHello = new ClientHello(name);
- fcpConnection.sendMessage(clientHello);
- while (true) {
- try {
- fcpListener.complete();
- break;
- } catch (InterruptedException e) {
- /* ignore, weâll loop. */
- }
- }
- fcpConnection.removeFcpListener(fcpListener);
- if (fcpListener.getFcpException() != null) {
- throw fcpListener.getFcpException();
- }
+ fcpListener.execute();
}
/**
@@ -169,13 +179,273 @@ public class FcpClient {
}
}
+ //
+ // PEER MANAGEMENT
+ //
+
+ /**
+ * Returns all peers that the node has.
+ *
+ * @param withMetadata
+ * true
to include peer metadata
+ * @param withVolatile
+ * true
to include volatile peer data
+ * @return A set containing the nodeâs peers
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public Set getPeers(final boolean withMetadata, final boolean withVolatile) throws IOException, FcpException {
+ final Set peers = new HashSet();
+ ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.sendMessage(new ListPeers("list-peers", withMetadata, withVolatile));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
+ peers.add(peer);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedEndListPeers(FcpConnection fcpConnection, EndListPeers endListPeers) {
+ completionLatch.countDown();
+ }
+ };
+ fcpListener.execute();
+ return peers;
+ }
+
+ /**
+ * Adds the given peer to the node.
+ *
+ * @param peer
+ * The peer to add
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void addPeer(Peer peer) throws IOException, FcpException {
+ addPeer(peer.getNodeRef());
+ }
+
+ /**
+ * Adds the peer defined by the noderef to the node.
+ *
+ * @param nodeRef
+ * The noderef that defines the new peer
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void addPeer(NodeRef nodeRef) throws IOException, FcpException {
+ addPeer(new AddPeer(nodeRef));
+ }
+
+ /**
+ * Adds a peer, reading the noderef from the given URL.
+ *
+ * @param url
+ * The URL to read the noderef from
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void addPeer(URL url) throws IOException, FcpException {
+ addPeer(new AddPeer(url));
+ }
+
+ /**
+ * Adds a peer, reading the noderef of the peer from the given file.
+ * Note: the file to read the noderef from has to reside on
+ * the same machine as the node!
+ *
+ * @param file
+ * The name of the file containing the peerâs noderef
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void addPeer(String file) throws IOException, FcpException {
+ addPeer(new AddPeer(file));
+ }
+
+ /**
+ * Sends the given {@link AddPeer} message to the node. This method should
+ * not be called directly. Use one of {@link #addPeer(Peer)},
+ * {@link #addPeer(NodeRef)}, {@link #addPeer(URL)}, or
+ * {@link #addPeer(String)} instead.
+ *
+ * @param addPeer
+ * The âAddPeerâ message
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ private void addPeer(final AddPeer addPeer) throws IOException, FcpException {
+ ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.sendMessage(addPeer);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
+ completionLatch.countDown();
+ }
+ };
+ fcpListener.execute();
+ }
+
+ /**
+ * Modifies the given peer.
+ *
+ * @param peer
+ * The peer to modify
+ * @param allowLocalAddresses
+ * true
to allow local address, false
+ * to not allow local address, null
to not change
+ * the setting
+ * @param disabled
+ * true
to disable the peer, false
to
+ * enable the peer, null
to not change the setting
+ * @param listenOnly
+ * true
to enable âlisten onlyâ for the peer,
+ * false
to disable it, null
to not
+ * change it
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void modifyPeer(final Peer peer, final Boolean allowLocalAddresses, final Boolean disabled, final Boolean listenOnly) throws IOException, FcpException {
+ ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.sendMessage(new ModifyPeer(peer.getIdentity(), allowLocalAddresses, disabled, listenOnly));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
+ completionLatch.countDown();
+ }
+ };
+ fcpListener.execute();
+ }
+
+ /**
+ * Removes the given peer.
+ *
+ * @param peer
+ * The peer to remove
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public void removePeer(final Peer peer) throws IOException, FcpException {
+ ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.sendMessage(new RemovePeer(peer.getIdentity()));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedPeerRemoved(FcpConnection fcpConnection, PeerRemoved peerRemoved) {
+ completionLatch.countDown();
+ }
+ };
+ fcpListener.execute();
+ }
+
+ //
+ // PEER NOTES MANAGEMENT
+ //
+
+ /**
+ * Returns the peer note of the given peer.
+ *
+ * @param peer
+ * The peer to get the note for
+ * @return The peerâs note
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
+ */
+ public PeerNote getPeerNote(final Peer peer) throws IOException, FcpException {
+ final ObjectWrapper objectWrapper = new ObjectWrapper();
+ new ExtendedFcpAdapter() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void run() throws IOException {
+ fcpConnection.sendMessage(new ListPeerNotes(peer.getIdentity()));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void receivedPeerNote(FcpConnection fcpConnection, PeerNote peerNote) {
+ objectWrapper.set(peerNote);
+ }
+ }.execute();
+ return objectWrapper.get();
+ }
+
/**
* Implementation of an {@link FcpListener} that can store an
* {@link FcpException} and wait for the arrival of a certain command.
*
* @author David âBombeâ Roden <bombe@freenetproject.org>
*/
- private static class ExtendedFcpAdapter extends FcpAdapter {
+ private abstract class ExtendedFcpAdapter extends FcpAdapter {
/** The count down latch used to wait for completion. */
protected final CountDownLatch completionLatch = new CountDownLatch(1);
@@ -191,24 +461,42 @@ public class FcpClient {
}
/**
- * Returns the FCP exception that occured. If no FCP exception occured,
- * null
is returned.
+ * Executes the FCP commands in {@link #run()}, wrapping the execution
+ * and catching exceptions.
*
- * @return The FCP exception that occured, or null
+ * @throws IOException
+ * if an I/O error occurs
+ * @throws FcpException
+ * if an FCP error occurs
*/
- public FcpException getFcpException() {
- return fcpException;
+ @SuppressWarnings("synthetic-access")
+ public void execute() throws IOException, FcpException {
+ fcpConnection.addFcpListener(this);
+ try {
+ run();
+ while (true) {
+ try {
+ completionLatch.await();
+ break;
+ } catch (InterruptedException ie1) {
+ /* ignore, weâll loop. */
+ }
+ }
+ } finally {
+ fcpConnection.removeFcpListener(this);
+ }
+ if (fcpException != null) {
+ throw fcpException;
+ }
}
/**
- * Waits for the completion of the command.
+ * The FCP commands that actually get executed.
*
- * @throws InterruptedException
- * if {@link CountDownLatch#await()} is interrupted
+ * @throws IOException
+ * if an I/O error occurs
*/
- public void complete() throws InterruptedException {
- completionLatch.await();
- }
+ public abstract void run() throws IOException;
/**
* {@inheritDoc}