X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fnet%2Fpterodactylus%2Ffcp%2Fhighlevel%2FFcpClient.java;h=8a7a90d071c0b158fb31bc083e7b0659391f6c29;hb=1a1ee191a57a6fc9e676b47ef068bd1f0403a1bc;hp=a958f07af9853d8dbe79fbbe2bd04c5351691562;hpb=5e6ccd8ae5879a82c3e4086baa8847d2ba48dfa6;p=jFCPlib.git

diff --git a/src/net/pterodactylus/fcp/highlevel/FcpClient.java b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
index a958f07..8a7a90d 100644
--- a/src/net/pterodactylus/fcp/highlevel/FcpClient.java
+++ b/src/net/pterodactylus/fcp/highlevel/FcpClient.java
@@ -20,6 +20,7 @@
 package net.pterodactylus.fcp.highlevel;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.URL;
 import java.net.UnknownHostException;
@@ -29,6 +30,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.Map.Entry;
 import java.util.concurrent.CountDownLatch;
 
 import net.pterodactylus.fcp.AddPeer;
@@ -38,6 +40,8 @@ import net.pterodactylus.fcp.DataFound;
 import net.pterodactylus.fcp.EndListPeerNotes;
 import net.pterodactylus.fcp.EndListPeers;
 import net.pterodactylus.fcp.EndListPersistentRequests;
+import net.pterodactylus.fcp.FCPPluginMessage;
+import net.pterodactylus.fcp.FCPPluginReply;
 import net.pterodactylus.fcp.FcpAdapter;
 import net.pterodactylus.fcp.FcpConnection;
 import net.pterodactylus.fcp.FcpListener;
@@ -81,6 +85,9 @@ public class FcpClient {
 	/** The underlying FCP connection. */
 	private final FcpConnection fcpConnection;
 
+	/** Whether the client is currently connected. */
+	private volatile boolean connected;
+
 	/**
 	 * Creates an FCP client with the given name.
 	 *
@@ -163,6 +170,8 @@ public class FcpClient {
 	 *             if an FCP error occurs
 	 */
 	public void connect() throws IOException, FcpException {
+		checkConnected(false);
+		connected = true;
 		new ExtendedFcpAdapter() {
 
 			/**
@@ -198,6 +207,16 @@ public class FcpClient {
 		}
 	}
 
+	/**
+	 * Returns whether this client is currently connected.
+	 *
+	 * @return {@code true} if the client is currently connected, {@code false}
+	 *         otherwise
+	 */
+	public boolean isConnected() {
+		return connected;
+	}
+
 	//
 	// PEER MANAGEMENT
 	//
@@ -651,6 +670,31 @@ public class FcpClient {
 	}
 
 	/**
+	 * Returns all currently visible persistent put requests.
+	 *
+	 * @param global
+	 *            <code>true</code> to return put requests from the global
+	 *            queue, <code>false</code> to only show requests from the
+	 *            client-local queue
+	 * @return All put requests
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 */
+	public Collection<Request> getPutRequests(final boolean global) throws IOException, FcpException {
+		return Filters.filteredCollection(getRequests(global), new Filter<Request>() {
+
+			/**
+			 * {@inheritDoc}
+			 */
+			public boolean filterObject(Request request) {
+				return request instanceof PutRequest;
+			}
+		});
+	}
+
+	/**
 	 * Returns all currently visible persistent requests.
 	 *
 	 * @param global
@@ -767,6 +811,80 @@ public class FcpClient {
 		return requests.values();
 	}
 
+	/**
+	 * Sends a message to a plugin and waits for the response.
+	 *
+	 * @param pluginClass
+	 *            The name of the plugin class
+	 * @param parameters
+	 *            The parameters for the plugin
+	 * @return The responses from the plugin
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 */
+	public Map<String, String> sendPluginMessage(String pluginClass, Map<String, String> parameters) throws IOException, FcpException {
+		return sendPluginMessage(pluginClass, parameters, 0, null);
+	}
+
+	/**
+	 * Sends a message to a plugin and waits for the response.
+	 *
+	 * @param pluginClass
+	 *            The name of the plugin class
+	 * @param parameters
+	 *            The parameters for the plugin
+	 * @param dataLength
+	 *            The length of the optional data stream, or {@code 0} if there
+	 *            is no optional data stream
+	 * @param dataInputStream
+	 *            The input stream for the payload, or {@code null} if there is
+	 *            no payload
+	 * @return The responses from the plugin
+	 * @throws FcpException
+	 *             if an FCP error occurs
+	 * @throws IOException
+	 *             if an I/O error occurs
+	 */
+	public Map<String, String> sendPluginMessage(final String pluginClass, final Map<String, String> parameters, final long dataLength, final InputStream dataInputStream) throws IOException, FcpException {
+		final Map<String, String> pluginReplies = Collections.synchronizedMap(new HashMap<String, String>());
+		new ExtendedFcpAdapter() {
+
+			@SuppressWarnings("synthetic-access")
+			private final String identifier = createIdentifier("FCPPluginMessage");
+
+			@Override
+			@SuppressWarnings("synthetic-access")
+			public void run() throws IOException {
+				FCPPluginMessage fcpPluginMessage = new FCPPluginMessage(pluginClass);
+				for (Entry<String, String> parameter : parameters.entrySet()) {
+					fcpPluginMessage.setParameter(parameter.getKey(), parameter.getValue());
+				}
+				fcpPluginMessage.setIdentifier(identifier);
+				if ((dataLength > 0) && (dataInputStream != null)) {
+					fcpPluginMessage.setDataLength(dataLength);
+					fcpPluginMessage.setPayloadInputStream(dataInputStream);
+				}
+				fcpConnection.sendMessage(fcpPluginMessage);
+			}
+
+			/**
+			 * {@inheritDoc}
+			 */
+			@Override
+			public void receivedFCPPluginReply(FcpConnection fcpConnection, FCPPluginReply fcpPluginReply) {
+				if (!fcpPluginReply.getIdentifier().equals(identifier)) {
+					return;
+				}
+				pluginReplies.putAll(fcpPluginReply.getReplies());
+				completionLatch.countDown();
+			}
+
+		}.execute();
+		return pluginReplies;
+	}
+
 	//
 	// PRIVATE METHODS
 	//
@@ -783,6 +901,28 @@ public class FcpClient {
 	}
 
 	/**
+	 * Checks whether the connection is in the required state.
+	 *
+	 * @param connected
+	 *            The required connection state
+	 * @throws FcpException
+	 *             if the connection is not in the required state
+	 */
+	private void checkConnected(boolean connected) throws FcpException {
+		if (this.connected != connected) {
+			throw new FcpException("Client is " + (connected ? "not" : "already") + " connected.");
+		}
+	}
+
+	/**
+	 * Tells the client that it is now disconnected. This method is called by
+	 * {@link ExtendedFcpAdapter} only.
+	 */
+	private void setDisconnected() {
+		connected = false;
+	}
+
+	/**
 	 * Implementation of an {@link FcpListener} that can store an
 	 * {@link FcpException} and wait for the arrival of a certain command.
 	 *
@@ -814,6 +954,7 @@ public class FcpClient {
 		 */
 		@SuppressWarnings("synthetic-access")
 		public void execute() throws IOException, FcpException {
+			checkConnected(true);
 			fcpConnection.addFcpListener(this);
 			try {
 				run();
@@ -825,10 +966,14 @@ public class FcpClient {
 						/* ignore, we’ll loop. */
 					}
 				}
+			} catch (IOException ioe1) {
+				setDisconnected();
+				throw ioe1;
 			} finally {
 				fcpConnection.removeFcpListener(this);
 			}
 			if (fcpException != null) {
+				setDisconnected();
 				throw fcpException;
 			}
 		}