import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Logger;
import net.pterodactylus.fcp.AddPeer;
import net.pterodactylus.fcp.AllData;
+import net.pterodactylus.fcp.ClientGet;
import net.pterodactylus.fcp.ClientHello;
import net.pterodactylus.fcp.CloseConnectionDuplicateClientName;
import net.pterodactylus.fcp.ConfigData;
import net.pterodactylus.fcp.PutFailed;
import net.pterodactylus.fcp.PutFetchable;
import net.pterodactylus.fcp.PutSuccessful;
+import net.pterodactylus.fcp.ReturnType;
import net.pterodactylus.fcp.SSKKeypair;
import net.pterodactylus.fcp.SimpleProgress;
import net.pterodactylus.fcp.StartedCompression;
/**
* A high-level client that allows simple yet full-featured access to a Freenet
* node.
- *
+ *
* @author David ‘Bombe’ Roden <bombe@freenetproject.org>
* @version $Id$
*/
/** The FCP connection to the node. */
private FcpConnection fcpConnection;
+ /** Listeners for high-level client events. */
+ private List<HighLevelClientListener> highLevelClientListeners = Collections.synchronizedList(new ArrayList<HighLevelClientListener>());
+
/** The listener for the connection. */
private HighLevelClientFcpListener highLevelClientFcpListener = new HighLevelClientFcpListener();
/** Mapping from directories to DDA callbacks. */
private Map<String, HighLevelCallback<DirectDiskAccessResult>> directDiskAccessCallbacks = Collections.synchronizedMap(new HashMap<String, HighLevelCallback<DirectDiskAccessResult>>());
+ /** Mapping from request identifiers to download callbacks. */
+ private Map<String, HighLevelProgressCallback<DownloadResult>> downloadCallbacks = Collections.synchronizedMap(new HashMap<String, HighLevelProgressCallback<DownloadResult>>());
+
/**
* Creates a new high-level client that connects to a node on
* <code>localhost</code>.
- *
+ *
* @param clientName
* The name of the client
* @throws UnknownHostException
/**
* Creates a new high-level client that connects to a node on the given
* host.
- *
+ *
* @param clientName
* The name of the client
* @param host
/**
* Creates a new high-level client that connects to a node on the given
* host.
- *
+ *
* @param clientName
* The name of the client
* @param host
/**
* Creates a new high-level client that connects to a node at the given
* address.
- *
+ *
* @param clientName
* The name of the client
* @param address
}
//
+ // EVENT MANAGEMENT
+ //
+
+ /**
+ * Adds the given high-level client listener to list of listeners.
+ *
+ * @param highLevelClientListener
+ * The listener to add
+ */
+ public void addHighLevelClientListener(HighLevelClientListener highLevelClientListener) {
+ highLevelClientListeners.add(highLevelClientListener);
+ }
+
+ /**
+ * Removes the given high-level client listener from the list of listeners.
+ *
+ * @param highLevelClientListener
+ * The listener to remove
+ */
+ public void removeHighLevelClientListener(HighLevelClientListener highLevelClientListener) {
+ highLevelClientListeners.remove(highLevelClientListener);
+ }
+
+ /**
+ * Notifies all listeners that a client has connected.
+ */
+ private void fireClientConnected() {
+ for (HighLevelClientListener highLevelClientListener: highLevelClientListeners) {
+ highLevelClientListener.clientConnected(this);
+ }
+ }
+
+ /**
+ * Notifies all listeners that a client has disconnected.
+ */
+ private void fireClientDisconnected() {
+ for (HighLevelClientListener highLevelClientListener: highLevelClientListeners) {
+ highLevelClientListener.clientDisconnected(this);
+ }
+ }
+
+ //
// ACCESSORS
//
+ /**
+ * Returns the FCP connection that backs this high-level client. This method
+ * should be used with care as fiddling around with the FCP connection can
+ * easily break the high-level client if you don’t know what you’re doing!
+ *
+ * @return The FCP connection of this client
+ */
+ public FcpConnection getFcpConnection() {
+ return fcpConnection;
+ }
+
//
// ACTIONS
//
/**
* Connects the client.
- *
+ *
* @return A callback with a connection result
* @throws IOException
* if an I/O error occurs communicating with the node
* Disconnects the client from the node.
*/
public void disconnect() {
+ fcpConnection.close();
+ fireClientDisconnected();
}
/**
* Generates a new SSK keypair.
- *
+ *
* @return A callback with the keypair
* @throws IOException
* if an I/O error occurs communicating with the node
public HighLevelCallback<KeyGenerationResult> generateKey() throws IOException {
String identifier = generateIdentifier("generateSSK");
GenerateSSK generateSSK = new GenerateSSK(identifier);
- HighLevelCallback<KeyGenerationResult> keyGenerationCallback = new HighLevelCallback<KeyGenerationResult>(new KeyGenerationResult());
+ HighLevelCallback<KeyGenerationResult> keyGenerationCallback = new HighLevelCallback<KeyGenerationResult>(new KeyGenerationResult(identifier));
keyGenerationCallbacks.put(identifier, keyGenerationCallback);
fcpConnection.sendMessage(generateSSK);
return keyGenerationCallback;
/**
* Gets a list of all peers from the node.
- *
+ *
* @return A callback with the peer list
* @throws IOException
* if an I/O error occurs with the node
public HighLevelCallback<PeerListResult> getPeers() throws IOException {
String identifier = generateIdentifier("listPeers");
ListPeers listPeers = new ListPeers(identifier, true, true);
- HighLevelCallback<PeerListResult> peerListCallback = new HighLevelCallback<PeerListResult>(new PeerListResult());
+ HighLevelCallback<PeerListResult> peerListCallback = new HighLevelCallback<PeerListResult>(new PeerListResult(identifier));
peerListCallbacks.put(identifier, peerListCallback);
fcpConnection.sendMessage(listPeers);
return peerListCallback;
/**
* Adds the peer whose noderef is stored in the given file.
- *
+ *
* @param nodeRefFile
* The name of the file the peer’s noderef is stored in
* @return A peer callback
public HighLevelCallback<PeerResult> addPeer(String nodeRefFile) throws IOException {
String identifier = generateIdentifier("addPeer");
AddPeer addPeer = new AddPeer(nodeRefFile);
- HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult());
+ HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult(identifier));
peerCallbacks.put(identifier, peerCallback);
fcpConnection.sendMessage(addPeer);
return peerCallback;
/**
* Adds the peer whose noderef is stored in the given file.
- *
+ *
* @param nodeRefURL
* The URL where the peer’s noderef is stored
* @return A peer callback
public HighLevelCallback<PeerResult> addPeer(URL nodeRefURL) throws IOException {
String identifier = generateIdentifier("addPeer");
AddPeer addPeer = new AddPeer(nodeRefURL);
- HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult());
+ HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult(identifier));
peerCallbacks.put(identifier, peerCallback);
fcpConnection.sendMessage(addPeer);
return peerCallback;
/**
* Adds the peer whose noderef is stored in the given file.
- *
+ *
* @param nodeRef
* The peer’s noderef
* @return A peer callback
public HighLevelCallback<PeerResult> addPeer(NodeRef nodeRef) throws IOException {
String identifier = generateIdentifier("addPeer");
AddPeer addPeer = new AddPeer(nodeRef);
- HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult());
+ HighLevelCallback<PeerResult> peerCallback = new HighLevelCallback<PeerResult>(new PeerResult(identifier));
peerCallbacks.put(identifier, peerCallback);
fcpConnection.sendMessage(addPeer);
return peerCallback;
* Checks whether direct disk access for the given directory is possible.
* You have to perform this check before you can upload or download anything
* from or the disk directly!
- *
+ *
* @param directory
* The directory to check
* @param wantRead
*/
public HighLevelCallback<DirectDiskAccessResult> checkDirectDiskAccess(String directory, boolean wantRead, boolean wantWrite) throws IOException {
TestDDARequest testDDARequest = new TestDDARequest(directory, wantRead, wantWrite);
- HighLevelCallback<DirectDiskAccessResult> directDiskAccessCallback = new HighLevelCallback<DirectDiskAccessResult>(new DirectDiskAccessResult());
+ HighLevelCallback<DirectDiskAccessResult> directDiskAccessCallback = new HighLevelCallback<DirectDiskAccessResult>(new DirectDiskAccessResult(directory));
directDiskAccessCallbacks.put(directory, directDiskAccessCallback);
fcpConnection.sendMessage(testDDARequest);
return directDiskAccessCallback;
}
+ /**
+ * Starts a download. Files can either be download to disk or streamed from
+ * the node. When downloading to disk you have to perform a direct disk
+ * access check for the directory you want to put the downloaded file in!
+ *
+ * @see #checkDirectDiskAccess(String, boolean, boolean)
+ * @param uri
+ * The URI to get
+ * @param filename
+ * The filename to save the data to, or <code>null</code> to
+ * retrieve the data as InputStream from the
+ * {@link DownloadResult}
+ * @param global
+ * Whether to put the download on the global queue
+ * @return A download result
+ * @throws IOException
+ * if an I/O error occurs communicating with the node
+ */
+ public HighLevelProgressCallback<DownloadResult> download(String uri, String filename, boolean global) throws IOException {
+ String identifier = generateIdentifier("download");
+ ClientGet clientGet = new ClientGet(uri, identifier, (filename == null) ? ReturnType.direct : ReturnType.disk);
+ clientGet.setGlobal(global);
+ HighLevelProgressCallback<DownloadResult> downloadCallback = new HighLevelProgressCallback<DownloadResult>(new DownloadResult(identifier));
+ downloadCallbacks.put(identifier, downloadCallback);
+ fcpConnection.sendMessage(clientGet);
+ return downloadCallback;
+ }
+
//
// PRIVATE METHODS
//
/**
* Generates an identifier for the given function.
- *
+ *
* @param function
* The name of the function
* @return An identifier
/**
* FCP listener for {@link HighLevelClient}.
- *
+ *
* @author David ‘Bombe’ Roden <bombe@freenetproject.org>
* @version $Id$
*/
* Creates a new FCP listener for {@link HighLevelClient}.
*/
HighLevelClientFcpListener() {
+ /* do nothing. */
}
//
/**
* Searches all callback collections for a callback with the given
* identifier and cancels it.
- *
+ *
* @param identifier
* The identifier to search for, or <code>null</code> to
* cancel all pending requests
directDiskAccessEntry.getValue().setDone();
}
directDiskAccessCallbacks.clear();
+ /* download callbacks. */
+ for (Entry<String, HighLevelProgressCallback<DownloadResult>> downloadEntry: downloadCallbacks.entrySet()) {
+ downloadEntry.getValue().getIntermediaryResult().setFailed(true);
+ downloadEntry.getValue().setDone();
+ }
+ downloadCallbacks.clear();
} else {
HighLevelCallback<KeyGenerationResult> keyGenerationCallback = keyGenerationCallbacks.remove(identifier);
if (keyGenerationCallback != null) {
directDiskAccessCallback.setDone();
return;
}
+ HighLevelProgressCallback<DownloadResult> downloadCallback = downloadCallbacks.remove(identifier);
+ if (downloadCallback != null) {
+ downloadCallback.getIntermediaryResult().setFailed(true);
+ downloadCallback.setDone();
+ return;
+ }
}
}
/**
* Reads the given file and returns the first line of the file.
- *
+ *
* @param readFilename
* The name of the file to read
* @return The content of the file
/**
* Writes the given content to the given file.
- *
+ *
* @param directDiskAccessResult
* The DDA result
* @param writeFilename
/**
* Cleans up any files that written for the given result.
- *
+ *
* @param directDiskAccessResult
* The direct disk access result
*/
* net.pterodactylus.fcp.AllData)
*/
public void receivedAllData(FcpConnection fcpConnection, AllData allData) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.CloseConnectionDuplicateClientName)
*/
public void receivedCloseConnectionDuplicateClientName(FcpConnection fcpConnection, CloseConnectionDuplicateClientName closeConnectionDuplicateClientName) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.ConfigData)
*/
public void receivedConfigData(FcpConnection fcpConnection, ConfigData configData) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.DataFound)
*/
public void receivedDataFound(FcpConnection fcpConnection, DataFound dataFound) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.EndListPeerNotes)
*/
public void receivedEndListPeerNotes(FcpConnection fcpConnection, EndListPeerNotes endListPeerNotes) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.EndListPersistentRequests)
*/
public void receivedEndListPersistentRequests(FcpConnection fcpConnection, EndListPersistentRequests endListPersistentRequests) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.FCPPluginReply)
*/
public void receivedFCPPluginReply(FcpConnection fcpConnection, FCPPluginReply fcpPluginReply) {
+ /* TODO */
}
/**
* @see net.pterodactylus.fcp.FcpListener#receivedGetFailed(net.pterodactylus.fcp.FcpConnection,
* net.pterodactylus.fcp.GetFailed)
*/
+ @SuppressWarnings("synthetic-access")
public void receivedGetFailed(FcpConnection fcpConnection, GetFailed getFailed) {
+ if (fcpConnection != HighLevelClient.this.fcpConnection) {
+ return;
+ }
+ String identifier = getFailed.getIdentifier();
+ HighLevelProgressCallback<DownloadResult> downloadCallback = downloadCallbacks.remove(identifier);
+ if (downloadCallback != null) {
+ downloadCallback.getIntermediaryResult().setFailed(true);
+ downloadCallback.setDone();
+ return;
+ }
+ /* unknown identifier? */
+ logger.warning("unknown identifier for GetFailed: " + identifier);
}
/**
* net.pterodactylus.fcp.IdentifierCollision)
*/
public void receivedIdentifierCollision(FcpConnection fcpConnection, IdentifierCollision identifierCollision) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.FcpMessage)
*/
public void receivedMessage(FcpConnection fcpConnection, FcpMessage fcpMessage) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.NodeData)
*/
public void receivedNodeData(FcpConnection fcpConnection, NodeData nodeData) {
+ /* TODO */
}
/**
connectCallback.setDone();
connectCallback = null;
}
+ fireClientConnected();
}
/**
if (peerResult != null) {
peerResult.getIntermediaryResult().setPeer(peer);
peerResult.setDone();
+ return;
}
+ logger.warning("got Peer message with unknown identifier: " + identifier);
}
/**
* net.pterodactylus.fcp.PeerNote)
*/
public void receivedPeerNote(FcpConnection fcpConnection, PeerNote peerNote) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PeerRemoved)
*/
public void receivedPeerRemoved(FcpConnection fcpConnection, PeerRemoved peerRemoved) {
+ /* TODO */
}
/**
* @see net.pterodactylus.fcp.FcpListener#receivedPersistentGet(net.pterodactylus.fcp.FcpConnection,
* net.pterodactylus.fcp.PersistentGet)
*/
+ @SuppressWarnings("synthetic-access")
public void receivedPersistentGet(FcpConnection fcpConnection, PersistentGet persistentGet) {
+ if (fcpConnection != HighLevelClient.this.fcpConnection) {
+ return;
+ }
+ String identifier = persistentGet.getIdentifier();
+ if (downloadCallbacks.containsKey(identifier)) {
+ /* ignore, because a download does not care about this. */
+ return;
+ }
}
/**
* net.pterodactylus.fcp.PersistentPut)
*/
public void receivedPersistentPut(FcpConnection fcpConnection, PersistentPut persistentPut) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PersistentPutDir)
*/
public void receivedPersistentPutDir(FcpConnection fcpConnection, PersistentPutDir persistentPutDir) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PersistentRequestModified)
*/
public void receivedPersistentRequestModified(FcpConnection fcpConnection, PersistentRequestModified persistentRequestModified) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PersistentRequestRemoved)
*/
public void receivedPersistentRequestRemoved(FcpConnection fcpConnection, PersistentRequestRemoved persistentRequestRemoved) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PluginInfo)
*/
public void receivedPluginInfo(FcpConnection fcpConnection, PluginInfo pluginInfo) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PutFailed)
*/
public void receivedPutFailed(FcpConnection fcpConnection, PutFailed putFailed) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PutFetchable)
*/
public void receivedPutFetchable(FcpConnection fcpConnection, PutFetchable putFetchable) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.PutSuccessful)
*/
public void receivedPutSuccessful(FcpConnection fcpConnection, PutSuccessful putSuccessful) {
+ /* TODO */
}
/**
* @see net.pterodactylus.fcp.FcpListener#receivedSimpleProgress(net.pterodactylus.fcp.FcpConnection,
* net.pterodactylus.fcp.SimpleProgress)
*/
+ @SuppressWarnings("synthetic-access")
public void receivedSimpleProgress(FcpConnection fcpConnection, SimpleProgress simpleProgress) {
+ if (fcpConnection != HighLevelClient.this.fcpConnection) {
+ return;
+ }
+ String identifier = simpleProgress.getIdentifier();
+ HighLevelProgressCallback<DownloadResult> downloadCallback = downloadCallbacks.get(identifier);
+ if (downloadCallback != null) {
+ DownloadResult downloadResult = downloadCallback.getIntermediaryResult();
+ downloadResult.setTotalBlocks(simpleProgress.getTotal());
+ downloadResult.setRequiredBlocks(simpleProgress.getRequired());
+ downloadResult.setSuccessfulBlocks(simpleProgress.getSucceeded());
+ downloadResult.setFailedBlocks(simpleProgress.getFailed());
+ downloadResult.setFatallyFailedBlocks(simpleProgress.getFatallyFailed());
+ downloadResult.setTotalFinalized(simpleProgress.isFinalizedTotal());
+ downloadCallback.progressUpdated();
+ return;
+ }
+ /* unknown identifier? */
+ logger.warning("unknown identifier for SimpleProgress: " + identifier);
}
/**
* net.pterodactylus.fcp.StartedCompression)
*/
public void receivedStartedCompression(FcpConnection fcpConnection, StartedCompression startedCompression) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.SubscribedUSKUpdate)
*/
public void receivedSubscribedUSKUpdate(FcpConnection fcpConnection, SubscribedUSKUpdate subscribedUSKUpdate) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.URIGenerated)
*/
public void receivedURIGenerated(FcpConnection fcpConnection, URIGenerated uriGenerated) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.UnknownNodeIdentifier)
*/
public void receivedUnknownNodeIdentifier(FcpConnection fcpConnection, UnknownNodeIdentifier unknownNodeIdentifier) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.UnknownPeerNoteType)
*/
public void receivedUnknownPeerNoteType(FcpConnection fcpConnection, UnknownPeerNoteType unknownPeerNoteType) {
+ /* TODO */
}
/**
* net.pterodactylus.fcp.FinishedCompression)
*/
public void receviedFinishedCompression(FcpConnection fcpConnection, FinishedCompression finishedCompression) {
+ /* TODO */
}
}
projects / jFCPlib.git / blobdiff