X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fnet%2Fpterodactylus%2Ffcp%2Fhighlevel%2FFcpClient.java;h=4af4426c87442e14fc1410f9066f75eb4c877ad5;hb=07b8dedfe353a27cb06c7f7d3086680829917c48;hp=5a3ec091afb6182cc71c71b9acb94a320fe97b80;hpb=d649abb6cc777878323c0e21ee665e88934d3873;p=jFCPlib.git

diff --git a/src/net/pterodactylus/fcp/highlevel/FcpClient.java b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
index 5a3ec09..4af4426 100644
--- a/src/net/pterodactylus/fcp/highlevel/FcpClient.java
+++ b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
@@ -23,23 +23,44 @@ import java.io.IOException;
 import java.net.InetAddress;
 import java.net.URL;
 import java.net.UnknownHostException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 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.DataFound;
+import net.pterodactylus.fcp.EndListPeerNotes;
 import net.pterodactylus.fcp.EndListPeers;
+import net.pterodactylus.fcp.EndListPersistentRequests;
 import net.pterodactylus.fcp.FcpAdapter;
 import net.pterodactylus.fcp.FcpConnection;
 import net.pterodactylus.fcp.FcpListener;
+import net.pterodactylus.fcp.GenerateSSK;
+import net.pterodactylus.fcp.GetFailed;
+import net.pterodactylus.fcp.ListPeerNotes;
 import net.pterodactylus.fcp.ListPeers;
+import net.pterodactylus.fcp.ListPersistentRequests;
 import net.pterodactylus.fcp.ModifyPeer;
+import net.pterodactylus.fcp.ModifyPeerNote;
 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.PersistentGet;
+import net.pterodactylus.fcp.PersistentPut;
 import net.pterodactylus.fcp.ProtocolError;
+import net.pterodactylus.fcp.RemovePeer;
+import net.pterodactylus.fcp.SSKKeypair;
+import net.pterodactylus.fcp.SimpleProgress;
+import net.pterodactylus.fcp.WatchGlobal;
+import net.pterodactylus.util.thread.ObjectWrapper;
 
 /**
  * High-level FCP client that hides the details of the underlying FCP
@@ -140,7 +161,20 @@ public class FcpClient {
 	 *             if an FCP error occurs
 	 */
 	public void connect() throws IOException, FcpException {
-		ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.connect();
+				ClientHello clientHello = new ClientHello(name);
+				fcpConnection.sendMessage(clientHello);
+				WatchGlobal watchGlobal = new WatchGlobal(true);
+				fcpConnection.sendMessage(watchGlobal);
+			}
 
 			/**
 			 * {@inheritDoc}
@@ -149,26 +183,7 @@ public class FcpClient {
 			public void receivedNodeHello(FcpConnection fcpConnection, NodeHello nodeHello) {
 				completionLatch.countDown();
 			}
-		};
-		fcpConnection.addFcpListener(fcpListener);
-		try {
-			fcpConnection.connect();
-			ClientHello clientHello = new ClientHello(name);
-			fcpConnection.sendMessage(clientHello);
-			while (true) {
-				try {
-					fcpListener.complete();
-					break;
-				} catch (InterruptedException e) {
-					/* ignore, we’ll loop. */
-				}
-			}
-		} finally {
-			fcpConnection.removeFcpListener(fcpListener);
-		}
-		if (fcpListener.getFcpException() != null) {
-			throw fcpListener.getFcpException();
-		}
+		}.execute();
 	}
 
 	/**
@@ -188,22 +203,41 @@ public class FcpClient {
 	/**
 	 * Returns all peers that the node has.
 	 *
+	 * @param withMetadata
+	 *            <code>true</code> to include peer metadata
+	 * @param withVolatile
+	 *            <code>true</code> 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<Peer> getPeers() throws IOException, FcpException {
-		final Set<Peer> peers = new HashSet<Peer>();
-		ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+	public Collection<Peer> getPeers(final boolean withMetadata, final boolean withVolatile) throws IOException, FcpException {
+		final Set<Peer> peers = Collections.synchronizedSet(new HashSet<Peer>());
+		new ExtendedFcpAdapter() {
+
+			/** The ID of the “ListPeers” request. */
+			@SuppressWarnings("synthetic-access")
+			private String identifier = createIdentifier("list-peers");
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(new ListPeers(identifier, withMetadata, withVolatile));
+			}
 
 			/**
 			 * {@inheritDoc}
 			 */
 			@Override
 			public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
-				peers.add(peer);
+				if (peer.getIdentifier().equals(identifier)) {
+					peers.add(peer);
+				}
 			}
 
 			/**
@@ -211,26 +245,11 @@ public class FcpClient {
 			 */
 			@Override
 			public void receivedEndListPeers(FcpConnection fcpConnection, EndListPeers endListPeers) {
-				completionLatch.countDown();
-			}
-		};
-		fcpConnection.addFcpListener(fcpListener);
-		fcpConnection.sendMessage(new ListPeers("list-peers"));
-		try {
-			while (true) {
-				try {
-					fcpListener.complete();
-					break;
-				} catch (InterruptedException e) {
-					/* ignore, we’ll loop. */
+				if (endListPeers.getIdentifier().equals(identifier)) {
+					completionLatch.countDown();
 				}
 			}
-		} finally {
-			fcpConnection.removeFcpListener(fcpListener);
-		}
-		if (fcpListener.getFcpException() != null) {
-			throw fcpListener.getFcpException();
-		}
+		}.execute();
 		return peers;
 	}
 
@@ -305,8 +324,17 @@ public class FcpClient {
 	 * @throws FcpException
 	 *             if an FCP error occurs
 	 */
-	private void addPeer(AddPeer addPeer) throws IOException, FcpException {
-		ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+	private void addPeer(final AddPeer addPeer) throws IOException, FcpException {
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(addPeer);
+			}
 
 			/**
 			 * {@inheritDoc}
@@ -315,24 +343,7 @@ public class FcpClient {
 			public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
 				completionLatch.countDown();
 			}
-		};
-		fcpConnection.addFcpListener(fcpListener);
-		try {
-			fcpConnection.sendMessage(addPeer);
-			while (true) {
-				try {
-					fcpListener.complete();
-					break;
-				} catch (InterruptedException ie1) {
-					/* ignore, we’ll loop. */
-				}
-			}
-		} finally {
-			fcpConnection.removeFcpListener(fcpListener);
-		}
-		if (fcpListener.getFcpException() != null) {
-			throw fcpListener.getFcpException();
-		}
+		}.execute();
 	}
 
 	/**
@@ -356,8 +367,17 @@ public class FcpClient {
 	 * @throws FcpException
 	 *             if an FCP error occurs
 	 */
-	public void modifyPeer(Peer peer, Boolean allowLocalAddresses, Boolean disabled, Boolean listenOnly) throws IOException, FcpException {
-		ExtendedFcpAdapter fcpListener = new ExtendedFcpAdapter() {
+	public void modifyPeer(final Peer peer, final Boolean allowLocalAddresses, final Boolean disabled, final Boolean listenOnly) throws IOException, FcpException {
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(new ModifyPeer(peer.getIdentity(), allowLocalAddresses, disabled, listenOnly));
+			}
 
 			/**
 			 * {@inheritDoc}
@@ -366,16 +386,305 @@ public class FcpClient {
 			public void receivedPeer(FcpConnection fcpConnection, Peer peer) {
 				completionLatch.countDown();
 			}
-		};
-		fcpConnection.addFcpListener(fcpListener);
-		try {
-			fcpConnection.sendMessage(new ModifyPeer(peer.getIdentity(), allowLocalAddresses, disabled, listenOnly));
-		} finally {
-			fcpConnection.removeFcpListener(fcpListener);
-		}
-		if (fcpListener.getFcpException() != null) {
-			throw fcpListener.getFcpException();
-		}
+		}.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 {
+		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();
+			}
+		}.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<PeerNote> objectWrapper = new ObjectWrapper<PeerNote>();
+		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) {
+				if (peerNote.getNodeIdentifier().equals(peer.getIdentity())) {
+					objectWrapper.set(peerNote);
+				}
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedEndListPeerNotes(FcpConnection fcpConnection, EndListPeerNotes endListPeerNotes) {
+				completionLatch.countDown();
+			}
+		}.execute();
+		return objectWrapper.get();
+	}
+
+	/**
+	 * Replaces the peer note for the given peer.
+	 *
+	 * @param peer
+	 *            The peer
+	 * @param noteText
+	 *            The new base64-encoded note text
+	 * @param noteType
+	 *            The type of the note (currently only <code>1</code> is
+	 *            allowed)
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 */
+	public void modifyPeerNote(final Peer peer, final String noteText, final int noteType) throws IOException, FcpException {
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(new ModifyPeerNote(peer.getIdentity(), noteText, noteType));
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedPeer(FcpConnection fcpConnection, Peer receivedPeer) {
+				if (receivedPeer.getIdentity().equals(peer.getIdentity())) {
+					completionLatch.countDown();
+				}
+			}
+		}.execute();
+	}
+
+	//
+	// KEY GENERATION
+	//
+
+	/**
+	 * Generates a new SSK key pair.
+	 *
+	 * @return The generated key pair
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 */
+	public SSKKeypair generateKeyPair() throws IOException, FcpException {
+		final ObjectWrapper<SSKKeypair> sskKeypairWrapper = new ObjectWrapper<SSKKeypair>();
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(new GenerateSSK());
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedSSKKeypair(FcpConnection fcpConnection, SSKKeypair sskKeypair) {
+				sskKeypairWrapper.set(sskKeypair);
+				completionLatch.countDown();
+			}
+		}.execute();
+		return sskKeypairWrapper.get();
+	}
+
+	//
+	// REQUEST MANAGEMENT
+	//
+
+	/**
+	 * Returns all currently visible persistent get requests.
+	 *
+	 * @param global
+	 *            <code>true</code> to return get requests from the global
+	 *            queue, <code>false</code> to only show requests from the
+	 *            client-local queue
+	 * @return All get requests
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 */
+	public Collection<Request> getGetRequests(final boolean global) throws IOException, FcpException {
+		return getRequests(global);
+	}
+
+	public Collection<Request> getRequests(final boolean global) throws IOException, FcpException {
+		final Map<String, Request> requests = Collections.synchronizedMap(new HashMap<String, Request>());
+		new ExtendedFcpAdapter() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				fcpConnection.sendMessage(new ListPersistentRequests());
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedPersistentGet(FcpConnection fcpConnection, PersistentGet persistentGet) {
+				if (!persistentGet.isGlobal() || global) {
+					GetRequest getRequest = new GetRequest(persistentGet);
+					requests.put(persistentGet.getIdentifier(), getRequest);
+				}
+			}
+
+			/**
+			 * {@inheritDoc}
+			 *
+			 * @see net.pterodactylus.fcp.FcpAdapter#receivedDataFound(net.pterodactylus.fcp.FcpConnection,
+			 *      net.pterodactylus.fcp.DataFound)
+			 */
+			@Override
+			public void receivedDataFound(FcpConnection fcpConnection, DataFound dataFound) {
+				Request getRequest = requests.get(dataFound.getIdentifier());
+				if (getRequest == null) {
+					return;
+				}
+				getRequest.setComplete(true);
+				getRequest.setLength(dataFound.getDataLength());
+				getRequest.setContentType(dataFound.getMetadataContentType());
+			}
+
+			/**
+			 * {@inheritDoc}
+			 *
+			 * @see net.pterodactylus.fcp.FcpAdapter#receivedGetFailed(net.pterodactylus.fcp.FcpConnection,
+			 *      net.pterodactylus.fcp.GetFailed)
+			 */
+			@Override
+			public void receivedGetFailed(FcpConnection fcpConnection, GetFailed getFailed) {
+				Request getRequest = requests.get(getFailed.getIdentifier());
+				if (getRequest == null) {
+					return;
+				}
+				getRequest.setComplete(true);
+				getRequest.setFailed(true);
+				getRequest.setFatal(getFailed.isFatal());
+				getRequest.setErrorCode(getFailed.getCode());
+			}
+
+			/**
+			 * {@inheritDoc}
+			 *
+			 * @see net.pterodactylus.fcp.FcpAdapter#receivedPersistentPut(net.pterodactylus.fcp.FcpConnection,
+			 *      net.pterodactylus.fcp.PersistentPut)
+			 */
+			@Override
+			public void receivedPersistentPut(FcpConnection fcpConnection, PersistentPut persistentPut) {
+				if (!persistentPut.isGlobal() || global) {
+					PutRequest putRequest = new PutRequest(persistentPut);
+					requests.put(persistentPut.getIdentifier(), putRequest);
+				}
+			}
+
+			/**
+			 * {@inheritDoc}
+			 *
+			 * @see net.pterodactylus.fcp.FcpAdapter#receivedSimpleProgress(net.pterodactylus.fcp.FcpConnection,
+			 *      net.pterodactylus.fcp.SimpleProgress)
+			 */
+			@Override
+			public void receivedSimpleProgress(FcpConnection fcpConnection, SimpleProgress simpleProgress) {
+				Request request = requests.get(simpleProgress.getIdentifier());
+				if (request == null) {
+					return;
+				}
+				request.setTotalBlocks(simpleProgress.getTotal());
+				request.setRequiredBlocks(simpleProgress.getRequired());
+				request.setFailedBlocks(simpleProgress.getFailed());
+				request.setFatallyFailedBlocks(simpleProgress.getFatallyFailed());
+				request.setSucceededBlocks(simpleProgress.getSucceeded());
+				request.setFinalizedTotal(simpleProgress.isFinalizedTotal());
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedEndListPersistentRequests(FcpConnection fcpConnection, EndListPersistentRequests endListPersistentRequests) {
+				completionLatch.countDown();
+			}
+		}.execute();
+		return requests.values();
+	}
+
+	//
+	// PRIVATE METHODS
+	//
+
+	/**
+	 * Creates a unique request identifier.
+	 *
+	 * @param basename
+	 *            The basename of the request
+	 * @return The created request identifier
+	 */
+	private String createIdentifier(String basename) {
+		return basename + "-" + System.currentTimeMillis() + "-" + (int) (Math.random() * Integer.MAX_VALUE);
 	}
 
 	/**
@@ -384,7 +693,7 @@ public class FcpClient {
 	 *
 	 * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 	 */
-	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);
@@ -400,24 +709,42 @@ public class FcpClient {
 		}
 
 		/**
-		 * Returns the FCP exception that occured. If no FCP exception occured,
-		 * <code>null</code> is returned.
+		 * Executes the FCP commands in {@link #run()}, wrapping the execution
+		 * and catching exceptions.
 		 *
-		 * @return The FCP exception that occured, or <code>null</code>
+		 * @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}