--- /dev/null
+/*
+ * jFCPlib-high-level-client - DDAResult.java -
+ * Copyright © 2008 David Roden
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package net.pterodactylus.fcp.highlevel;
+
+/**
+ * The result of a direct disk access check.
+ *
+ * @author David ‘Bombe’ Roden <bombe@freenetproject.org>
+ * @version $Id$
+ */
+public class DirectDiskAccessResult extends HighLevelResult {
+
+ /** Whether reading is allowed. */
+ private boolean readAllowed;
+
+ /** Whether writing is allowed. */
+ private boolean writeAllowed;
+
+ /**
+ * Package-private constructor.
+ */
+ DirectDiskAccessResult() {
+ }
+
+ /**
+ * Returns whether reading the directory is allowed.
+ *
+ * @return <code>true</code> if the client is allowed to read from the
+ * directory, <code>false</code> otherwise
+ */
+ public boolean isReadAllowed() {
+ return readAllowed;
+ }
+
+ /**
+ * Sets whether reading the directory is allowed.
+ *
+ * @param readAllowed
+ * <code>true</code> if the client is allowed to read from the
+ * directory, <code>false</code> otherwise
+ */
+ void setReadAllowed(boolean readAllowed) {
+ this.readAllowed = readAllowed;
+ }
+
+ /**
+ * Returns whether writing to the directory is allowed.
+ *
+ * @return <code>true</code> if the client is allowed to write to the
+ * directory, <code>false</code> otherwise
+ */
+ public boolean isWriteAllowed() {
+ return writeAllowed;
+ }
+
+ /**
+ * Sets whether writing to the directory is allowed.
+ *
+ * @param writeAllowed
+ * <code>true</code> if the client is allowed to write to the
+ * directory, <code>false</code> otherwise
+ */
+ void setWriteAllowed(boolean writeAllowed) {
+ this.writeAllowed = writeAllowed;
+ }
+
+}
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;
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.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;
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;
*/
public class HighLevelClient {
+ /** Logger. */
+ private static final Logger logger = Logger.getLogger(HighLevelClient.class.getName());
+
/** Object for internal synchronization. */
private final Object syncObject = new Object();
/** Mapping from request identifier to peer callbacks. */
private Map<String, HighLevelCallback<PeerResult>> peerCallbacks = Collections.synchronizedMap(new HashMap<String, HighLevelCallback<PeerResult>>());
+ /** Mapping from directories to DDA callbacks. */
+ private Map<String, HighLevelCallback<DirectDiskAccessResult>> directDiskAccessCallbacks = Collections.synchronizedMap(new HashMap<String, HighLevelCallback<DirectDiskAccessResult>>());
+
/**
* Creates a new high-level client that connects to a node on
* <code>localhost</code>.
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<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());
+ directDiskAccessCallbacks.put(directory, directDiskAccessCallback);
+ fcpConnection.sendMessage(testDDARequest);
+ return directDiskAccessCallback;
+ }
+
//
// PRIVATE METHODS
//
*/
private class HighLevelClientFcpListener implements FcpListener {
+ /** Mapping from directory to written file (for cleanup). */
+ private final Map<DirectDiskAccessResult, String> writtenFiles = new HashMap<DirectDiskAccessResult, String>();
+
/**
* Creates a new FCP listener for {@link HighLevelClient}.
*/
peerEntry.getValue().setDone();
}
peerCallbacks.clear();
+ /* direct disk access callbacks. */
+ for (Entry<String, HighLevelCallback<DirectDiskAccessResult>> directDiskAccessEntry: directDiskAccessCallbacks.entrySet()) {
+ directDiskAccessEntry.getValue().getIntermediaryResult().setFailed(true);
+ directDiskAccessEntry.getValue().setDone();
+ }
+ directDiskAccessCallbacks.clear();
} else {
HighLevelCallback<KeyGenerationResult> keyGenerationCallback = keyGenerationCallbacks.remove(identifier);
if (keyGenerationCallback != null) {
peerCallback.setDone();
return;
}
+ HighLevelCallback<DirectDiskAccessResult> directDiskAccessCallback = directDiskAccessCallbacks.remove(identifier);
+ if (directDiskAccessCallback != null) {
+ directDiskAccessCallback.getIntermediaryResult().setFailed(true);
+ directDiskAccessCallback.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);
+ }
}
}
* @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<DirectDiskAccessResult> 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. */
+ }
}
/**
projects / jFCPlib.git / commitdiff