X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fnet%2Fpterodactylus%2Ffcp%2Fhighlevel%2FHighLevelClient.java;h=0ec6da6f44761cd2936e719bf4cb0887db601094;hb=16353715c279d8b535b7aabb287764e591788c92;hp=4671245507af03ffab8ee4410337e34d55a28639;hpb=6e21203105cf44107c51d80ad8d98816726023b5;p=jFCPlib.git diff --git a/src/net/pterodactylus/fcp/highlevel/HighLevelClient.java b/src/net/pterodactylus/fcp/highlevel/HighLevelClient.java index 4671245..0ec6da6 100644 --- a/src/net/pterodactylus/fcp/highlevel/HighLevelClient.java +++ b/src/net/pterodactylus/fcp/highlevel/HighLevelClient.java @@ -19,6 +19,10 @@ package net.pterodactylus.fcp.highlevel; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; import java.io.IOException; import java.net.InetAddress; import java.net.URL; @@ -27,9 +31,11 @@ import java.util.Collections; import java.util.HashMap; 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; @@ -41,6 +47,7 @@ import net.pterodactylus.fcp.FCPPluginReply; import net.pterodactylus.fcp.FcpConnection; import net.pterodactylus.fcp.FcpListener; import net.pterodactylus.fcp.FcpMessage; +import net.pterodactylus.fcp.FcpUtils; import net.pterodactylus.fcp.FinishedCompression; import net.pterodactylus.fcp.GenerateSSK; import net.pterodactylus.fcp.GetFailed; @@ -62,12 +69,15 @@ import net.pterodactylus.fcp.ProtocolError; 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; import net.pterodactylus.fcp.SubscribedUSKUpdate; import net.pterodactylus.fcp.TestDDAComplete; import net.pterodactylus.fcp.TestDDAReply; +import net.pterodactylus.fcp.TestDDARequest; +import net.pterodactylus.fcp.TestDDAResponse; import net.pterodactylus.fcp.URIGenerated; import net.pterodactylus.fcp.UnknownNodeIdentifier; import net.pterodactylus.fcp.UnknownPeerNoteType; @@ -81,6 +91,9 @@ import net.pterodactylus.fcp.UnknownPeerNoteType; */ public class HighLevelClient { + /** Logger. */ + private static final Logger logger = Logger.getLogger(HighLevelClient.class.getName()); + /** Object for internal synchronization. */ private final Object syncObject = new Object(); @@ -111,6 +124,12 @@ public class HighLevelClient { /** Mapping from request identifier to peer callbacks. */ private Map> peerCallbacks = Collections.synchronizedMap(new HashMap>()); + /** Mapping from directories to DDA callbacks. */ + private Map> directDiskAccessCallbacks = Collections.synchronizedMap(new HashMap>()); + + /** Mapping from request identifiers to download callbacks. */ + private Map> downloadCallbacks = Collections.synchronizedMap(new HashMap>()); + /** * Creates a new high-level client that connects to a node on * localhost. @@ -213,7 +232,7 @@ public class HighLevelClient { public HighLevelCallback generateKey() throws IOException { String identifier = generateIdentifier("generateSSK"); GenerateSSK generateSSK = new GenerateSSK(identifier); - HighLevelCallback keyGenerationCallback = new HighLevelCallback(new KeyGenerationResult()); + HighLevelCallback keyGenerationCallback = new HighLevelCallback(new KeyGenerationResult(identifier)); keyGenerationCallbacks.put(identifier, keyGenerationCallback); fcpConnection.sendMessage(generateSSK); return keyGenerationCallback; @@ -229,7 +248,7 @@ public class HighLevelClient { public HighLevelCallback getPeers() throws IOException { String identifier = generateIdentifier("listPeers"); ListPeers listPeers = new ListPeers(identifier, true, true); - HighLevelCallback peerListCallback = new HighLevelCallback(new PeerListResult()); + HighLevelCallback peerListCallback = new HighLevelCallback(new PeerListResult(identifier)); peerListCallbacks.put(identifier, peerListCallback); fcpConnection.sendMessage(listPeers); return peerListCallback; @@ -247,7 +266,7 @@ public class HighLevelClient { public HighLevelCallback addPeer(String nodeRefFile) throws IOException { String identifier = generateIdentifier("addPeer"); AddPeer addPeer = new AddPeer(nodeRefFile); - HighLevelCallback peerCallback = new HighLevelCallback(new PeerResult()); + HighLevelCallback peerCallback = new HighLevelCallback(new PeerResult(identifier)); peerCallbacks.put(identifier, peerCallback); fcpConnection.sendMessage(addPeer); return peerCallback; @@ -265,7 +284,7 @@ public class HighLevelClient { public HighLevelCallback addPeer(URL nodeRefURL) throws IOException { String identifier = generateIdentifier("addPeer"); AddPeer addPeer = new AddPeer(nodeRefURL); - HighLevelCallback peerCallback = new HighLevelCallback(new PeerResult()); + HighLevelCallback peerCallback = new HighLevelCallback(new PeerResult(identifier)); peerCallbacks.put(identifier, peerCallback); fcpConnection.sendMessage(addPeer); return peerCallback; @@ -283,12 +302,62 @@ public class HighLevelClient { public HighLevelCallback addPeer(NodeRef nodeRef) throws IOException { String identifier = generateIdentifier("addPeer"); AddPeer addPeer = new AddPeer(nodeRef); - HighLevelCallback peerCallback = new HighLevelCallback(new PeerResult()); + HighLevelCallback peerCallback = new HighLevelCallback(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 + * Whether you want to read the given directory + * @param wantWrite + * Whether you want to write to the given directory + * @return A direct disk access callback + * @throws IOException + */ + public HighLevelCallback checkDirectDiskAccess(String directory, boolean wantRead, boolean wantWrite) throws IOException { + TestDDARequest testDDARequest = new TestDDARequest(directory, wantRead, wantWrite); + HighLevelCallback directDiskAccessCallback = new HighLevelCallback(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 null 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 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 downloadCallback = new HighLevelProgressCallback(new DownloadResult(identifier)); + downloadCallbacks.put(identifier, downloadCallback); + fcpConnection.sendMessage(clientGet); + return downloadCallback; + } + // // PRIVATE METHODS // @@ -312,6 +381,9 @@ public class HighLevelClient { */ private class HighLevelClientFcpListener implements FcpListener { + /** Mapping from directory to written file (for cleanup). */ + private final Map writtenFiles = new HashMap(); + /** * Creates a new FCP listener for {@link HighLevelClient}. */ @@ -358,6 +430,18 @@ public class HighLevelClient { peerEntry.getValue().setDone(); } peerCallbacks.clear(); + /* direct disk access callbacks. */ + for (Entry> directDiskAccessEntry: directDiskAccessCallbacks.entrySet()) { + directDiskAccessEntry.getValue().getIntermediaryResult().setFailed(true); + directDiskAccessEntry.getValue().setDone(); + } + directDiskAccessCallbacks.clear(); + /* download callbacks. */ + for (Entry> downloadEntry: downloadCallbacks.entrySet()) { + downloadEntry.getValue().getIntermediaryResult().setFailed(true); + downloadEntry.getValue().setDone(); + } + downloadCallbacks.clear(); } else { HighLevelCallback keyGenerationCallback = keyGenerationCallbacks.remove(identifier); if (keyGenerationCallback != null) { @@ -377,6 +461,84 @@ public class HighLevelClient { peerCallback.setDone(); return; } + HighLevelCallback directDiskAccessCallback = directDiskAccessCallbacks.remove(identifier); + if (directDiskAccessCallback != null) { + directDiskAccessCallback.getIntermediaryResult().setFailed(true); + directDiskAccessCallback.setDone(); + return; + } + HighLevelProgressCallback 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 + */ + private String readContent(String readFilename) { + FileReader fileReader = null; + BufferedReader bufferedFileReader = null; + try { + fileReader = new FileReader(readFilename); + bufferedFileReader = new BufferedReader(fileReader); + String content = bufferedFileReader.readLine(); + return content; + } catch (IOException ioe1) { + /* swallow. */ + } finally { + FcpUtils.close(bufferedFileReader); + FcpUtils.close(fileReader); + } + return null; + } + + /** + * Writes the given content to the given file. + * + * @param directDiskAccessResult + * The DDA result + * @param writeFilename + * The name of the file to write to + * @param writeContent + * The content to write to the file + */ + private void writeContent(DirectDiskAccessResult directDiskAccessResult, String writeFilename, String writeContent) { + if ((writeFilename == null) || (writeContent == null)) { + return; + } + writtenFiles.put(directDiskAccessResult, writeFilename); + FileWriter fileWriter = null; + try { + fileWriter = new FileWriter(writeFilename); + fileWriter.write(writeContent); + } catch (IOException ioe1) { + /* swallow. */ + } finally { + FcpUtils.close(fileWriter); + } + } + + /** + * Cleans up any files that written for the given result. + * + * @param directDiskAccessResult + * The direct disk access result + */ + @SuppressWarnings("synthetic-access") + private void cleanFiles(DirectDiskAccessResult directDiskAccessResult) { + String writeFilename = writtenFiles.remove(directDiskAccessResult); + if (writeFilename != null) { + if (!new File(writeFilename).delete()) { + logger.warning("could not delete " + writeFilename); + } } } @@ -465,7 +627,20 @@ public class HighLevelClient { * @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 downloadCallback = downloadCallbacks.remove(identifier); + if (downloadCallback != null) { + downloadCallback.getIntermediaryResult().setFailed(true); + downloadCallback.setDone(); + return; + } + /* unknown identifier? */ + logger.warning("unknown identifier for GetFailed: " + identifier); } /** @@ -527,7 +702,9 @@ public class HighLevelClient { if (peerResult != null) { peerResult.getIntermediaryResult().setPeer(peer); peerResult.setDone(); + return; } + logger.warning("got Peer message with unknown identifier: " + identifier); } /** @@ -548,7 +725,16 @@ public class HighLevelClient { * @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; + } } /** @@ -646,7 +832,26 @@ public class HighLevelClient { * @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 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); } /** @@ -667,14 +872,48 @@ public class HighLevelClient { * @see net.pterodactylus.fcp.FcpListener#receivedTestDDAComplete(net.pterodactylus.fcp.FcpConnection, * net.pterodactylus.fcp.TestDDAComplete) */ + @SuppressWarnings("synthetic-access") public void receivedTestDDAComplete(FcpConnection fcpConnection, TestDDAComplete testDDAComplete) { + if (fcpConnection != HighLevelClient.this.fcpConnection) { + return; + } + String directory = testDDAComplete.getDirectory(); + if (directory == null) { + return; + } + HighLevelCallback directDiskAccessCallback = directDiskAccessCallbacks.remove(directory); + DirectDiskAccessResult directDiskAccessResult = directDiskAccessCallback.getIntermediaryResult(); + cleanFiles(directDiskAccessResult); + directDiskAccessResult.setReadAllowed(testDDAComplete.isReadDirectoryAllowed()); + directDiskAccessResult.setWriteAllowed(testDDAComplete.isWriteDirectoryAllowed()); + directDiskAccessCallback.setDone(); } /** * @see net.pterodactylus.fcp.FcpListener#receivedTestDDAReply(net.pterodactylus.fcp.FcpConnection, * net.pterodactylus.fcp.TestDDAReply) */ + @SuppressWarnings("synthetic-access") public void receivedTestDDAReply(FcpConnection fcpConnection, TestDDAReply testDDAReply) { + if (fcpConnection != HighLevelClient.this.fcpConnection) { + return; + } + String directory = testDDAReply.getDirectory(); + if (directory == null) { + return; + } + DirectDiskAccessResult directDiskAccessResult = directDiskAccessCallbacks.get(directory).getIntermediaryResult(); + String readFilename = testDDAReply.getReadFilename(); + String readContent = readContent(readFilename); + String writeFilename = testDDAReply.getWriteFilename(); + String writeContent = testDDAReply.getContentToWrite(); + writeContent(directDiskAccessResult, writeFilename, writeContent); + TestDDAResponse testDDAResponse = new TestDDAResponse(directory, readContent); + try { + fcpConnection.sendMessage(testDDAResponse); + } catch (IOException e) { + /* swallow. I’m verry unhappy about this. */ + } } /**