package freenet.clients.fcp;
import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.UUID;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import freenet.client.async.ClientContext;
import freenet.client.async.PersistenceDisabledException;
import freenet.client.async.PersistentJob;
import freenet.client.async.TooManyFilesInsertException;
import freenet.clients.fcp.ClientRequest.Persistence;
import freenet.node.RequestClient;
import freenet.node.RequestClientBuilder;
import freenet.pluginmanager.PluginManager;
import freenet.pluginmanager.PluginNotFoundException;
import freenet.pluginmanager.PluginRespirator;
import freenet.support.HexUtil;
import freenet.support.LogThresholdCallback;
import freenet.support.Logger;
import freenet.support.Logger.LogLevel;
import freenet.support.api.BucketFactory;
import freenet.support.io.Closer;
import freenet.support.io.FileUtil;
import freenet.support.io.NativeThread;
public class FCPConnectionHandler implements Closeable {
private static final class DirectoryAccess {
final boolean canWrite;
final boolean canRead;
public DirectoryAccess(boolean canRead, boolean canWrite) {
this.canRead = canRead;
this.canWrite = canWrite;
}
}
public static class DDACheckJob {
final File directory, readFilename, writeFilename;
final String readContent, writeContent;
/**
* null if not requested.
*/
DDACheckJob(Random r, File directory, File readFilename, File writeFilename) {
this.directory = directory;
this.readFilename = readFilename;
this.writeFilename = writeFilename;
byte[] random = new byte[128];
r.nextBytes(random);
this.readContent = HexUtil.bytesToHex(random);
r.nextBytes(random);
this.writeContent = HexUtil.bytesToHex(random);
}
}
final FCPServer server;
final Socket sock;
final FCPConnectionInputHandler inputHandler;
final Map<String, SubscribeUSK> uskSubscriptions;
public final FCPConnectionOutputHandler outputHandler;
private boolean isClosed;
private boolean inputClosed;
private boolean outputClosed;
private String clientName;
private PersistentRequestClient rebootClient;
private PersistentRequestClient foreverClient;
final BucketFactory bf;
final HashMap<String, ClientRequest> requestsByIdentifier;
/**
* {@link FCPPluginConnectionImpl} indexed by the server plugin name (see
* {@link PluginManager#getPluginFCPServer(String)}.<br><br>
*
* This also serves the same purpose as the client which is connected to this would normally
* be responsible for if it was running as a plugin in the node (as specified by
* {@link PluginRespirator#connectToOtherPlugin(String, ClientSideFCPMessageHandler)}):<br>
* It keeps strong references to the {@link FCPPluginConnectionImpl} objects, and thereby marks
* them as alive.<br>
* This in turn causes the {@link FCPPluginConnectionImpl} objects to stay available in the
* {@link FCPPluginConnectionTracker}, which allows server plugins to query them by their ID.
*/
private final TreeMap<String, FCPPluginConnectionImpl> pluginConnectionsByServerName
= new TreeMap<String, FCPPluginConnectionImpl>();
/**
* Lock for {@link #pluginConnectionsByServerName}.
*
* A {@link ReadWriteLock} because the usage pattern is mostly reads, very few writes -
* {@link ReadWriteLock} can do that faster than a regular Lock.
* (A {@link ReentrantReadWriteLock} because thats the only implementation of
* {@link ReadWriteLock}.)
*/
private final ReadWriteLock pluginConnectionsByServerName_Lock
= new ReentrantReadWriteLock();
/**
* 16 random bytes hex-encoded as String. Unique for each instance of this class.
*
* @deprecated Use {@link #connectionIdentifierUUID} instead.
*/
@Deprecated
public final String connectionIdentifier;
/** Random UUID unique for each instance of this class */
protected final UUID connectionIdentifierUUID;
private static volatile boolean logMINOR;
private boolean killedDupe;
static {
Logger.registerLogThresholdCallback(new LogThresholdCallback(){
@Override
public void shouldUpdate(){
logMINOR = Logger.shouldLog(LogLevel.MINOR, this);
}
});
}
// We are confident that the given client can access those
private final HashMap<String, DirectoryAccess> checkedDirectories = new HashMap<String, DirectoryAccess>();
// DDACheckJobs in flight
private final HashMap<File, DDACheckJob> inTestDirectories = new HashMap<File, DDACheckJob>();
public final RequestClient connectionRequestClientBulk = new RequestClientBuilder().build();
public final RequestClient connectionRequestClientRT = new RequestClientBuilder().realTime().build();
public FCPConnectionHandler(Socket s, FCPServer server) {
this.sock = s;
this.server = server;
isClosed = false;
this.bf = server.core.tempBucketFactory;
requestsByIdentifier = new HashMap<String, ClientRequest>();
uskSubscriptions = new HashMap<String, SubscribeUSK>();
this.inputHandler = new FCPConnectionInputHandler(this);
this.outputHandler = new FCPConnectionOutputHandler(this);
byte[] identifier = new byte[16];
server.node.random.nextBytes(identifier);
this.connectionIdentifier = HexUtil.bytesToHex(identifier);
// The random 16-byte identifier was used before we added the UUID. Luckily, UUIDs are also
// 16 byetes, so we can re-use the bytes.
// TODO: When getting rid of the non-UUID connectionIdentifier, use UUID.randomUUID();
this.connectionIdentifierUUID = UUID.nameUUIDFromBytes(identifier);
}
/**
* Queues the message for sending at the {@link FCPConnectionOutputHandler}.<br>
* <br>
*
* ATTENTION: The function will return immediately before even trying to send the message, the
* message will be sent asynchronously.<br>
* As a consequence, this function not throwing does not give any guarantee whatsoever that the
* message will ever be sent.
*/
@SuppressWarnings("deprecation")
public final void send(final FCPMessage message) {
outputHandler.queue(message);
}
void start() {
inputHandler.start();
outputHandler.start();
}
@Override
public void close() {
ClientRequest[] requests;
if(rebootClient != null)
rebootClient.onLostConnection(this);
if(foreverClient != null)
foreverClient.onLostConnection(this);
boolean dupe;
SubscribeUSK[] uskSubscriptions2;
synchronized(this) {
if(isClosed) {
// This is normal, both input and output handlers will call close().
return;
}
isClosed = true;
requests = new ClientRequest[requestsByIdentifier.size()];
requests = requestsByIdentifier.values().toArray(requests);
requestsByIdentifier.clear();
uskSubscriptions2 = uskSubscriptions.values().toArray(new SubscribeUSK[uskSubscriptions.size()]);
dupe = killedDupe;
}
for(ClientRequest req : requests)
req.onLostConnection(server.core.clientContext);
for(SubscribeUSK sub : uskSubscriptions2)
sub.unsubscribe();
if(!dupe) {
try {
server.core.clientContext.jobRunner.queue(new PersistentJob() {
@Override
public boolean run(ClientContext context) {
if((rebootClient != null) && !rebootClient.hasPersistentRequests())
server.unregisterClient(rebootClient);
if(foreverClient != null) {
if(!foreverClient.hasPersistentRequests())
server.unregisterClient(foreverClient);
}
return false;
}
}, NativeThread.NORM_PRIORITY);
} catch (PersistenceDisabledException e) {
// Ignore
}
}
outputHandler.onClosed();
}
synchronized void setKilledDupe() {
killedDupe = true;
}
public synchronized boolean isClosed() {
return isClosed;
}
public void closedInput() {
try {
sock.shutdownInput();
} catch (IOException e) {
// Ignore
}
synchronized(this) {
inputClosed = true;
if(!outputClosed) return;
}
try {
sock.close();
} catch (IOException e) {
// Ignore
}
}
public void closedOutput() {
try {
sock.shutdownOutput();
} catch (IOException e) {
// Ignore
}
synchronized(this) {
outputClosed = true;
if(!inputClosed) return;
}
try {
sock.close();
} catch (IOException e) {
// Ignore
}
}
public void setClientName(final String name) {
this.clientName = name;
rebootClient = server.registerRebootClient(name, server.core, this);
rebootClient.queuePendingMessagesOnConnectionRestartAsync(outputHandler, server.core.clientContext);
// Create foreverClient lazily. Everything that needs it (especially creating ClientGet's etc) runs on a database job.
if(logMINOR)
Logger.minor(this, "Set client name: "+name);
PersistentRequestClient client = server.getForeverClient(name, server.core, this);
if(client != null) {
synchronized(this) {
foreverClient = client;
}
foreverClient.queuePendingMessagesOnConnectionRestartAsync(outputHandler, server.core.clientContext);
}
}
protected PersistentRequestClient createForeverClient(String name) {
synchronized(FCPConnectionHandler.this) {
if(foreverClient != null) return foreverClient;
}
PersistentRequestClient client = server.registerForeverClient(name, server.core, FCPConnectionHandler.this);
synchronized(FCPConnectionHandler.this) {
foreverClient = client;
FCPConnectionHandler.this.notifyAll();
}
client.queuePendingMessagesOnConnectionRestartAsync(outputHandler, server.core.clientContext);
return foreverClient;
}
public String getClientName() {
return clientName;
}
// FIXME next 3 methods are in need of refactoring!
/**
* Start a ClientGet. If there is an identifier collision, queue an IdentifierCollisionMessage.
* Hence, we can run stuff on other threads if we need to, as long as we send the right messages.
*/
public void startClientGet(final ClientGetMessage message) {
final String id = message.identifier;
final boolean global = message.global;
ClientGet cg = null;
boolean success;
boolean persistent = message.persistence != Persistence.CONNECTION;
synchronized(this) {
if(isClosed) return;
// We need to track non-persistent requests anyway, so we may as well check
if(persistent)
success = true;
else
success = !requestsByIdentifier.containsKey(id);
if(success) {
try {
if(!persistent) {
cg = new ClientGet(this, message, server.core);
requestsByIdentifier.put(id, cg);
} else if(message.persistence == Persistence.FOREVER) {
try {
server.core.clientContext.jobRunner.queue(new PersistentJob() {
@Override
public boolean run(ClientContext context) {
ClientGet getter;
try {
getter = new ClientGet(FCPConnectionHandler.this, message, server.core);
} catch (IdentifierCollisionException e1) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, message.global);
outputHandler.queue(msg);
return false;
} catch (MessageInvalidException e1) {
outputHandler.queue(new ProtocolErrorMessage(e1.protocolCode, false, e1.getMessage(), e1.ident, e1.global));
return false;
}
try {
getter.register(false);
} catch (IdentifierCollisionException e) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, global);
outputHandler.queue(msg);
return false;
}
getter.start(context);
return true;
}
}, NativeThread.HIGH_PRIORITY-1);
} catch (PersistenceDisabledException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.PERSISTENCE_DISABLED, false, "Persistence is disabled", id, global));
return;
}
return; // Don't run the start() below
} else {
cg = new ClientGet(this, message, server.core);
}
} catch (IdentifierCollisionException e) {
success = false;
} catch (MessageInvalidException e) {
outputHandler.queue(new ProtocolErrorMessage(e.protocolCode, false, e.getMessage(), e.ident, e.global));
return;
}
}
}
if(message.persistence == Persistence.REBOOT)
try {
cg.register(false);
} catch (IdentifierCollisionException e) {
success = false;
}
if(!success) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, message.global);
outputHandler.queue(msg);
return;
} else {
cg.start(server.core.clientContext);
}
}
public void startClientPut(final ClientPutMessage message) {
if(logMINOR)
Logger.minor(this, "Starting insert ID=\""+message.identifier+ '"');
final String id = message.identifier;
final boolean global = message.global;
ClientPut cp = null;
boolean persistent = message.persistence != Persistence.CONNECTION;
FCPMessage failedMessage = null;
synchronized(this) {
boolean success;
if(isClosed) {
if(logMINOR) Logger.minor(this, "Connection is closed");
return;
}
// We need to track non-persistent requests anyway, so we may as well check
if(persistent)
success = true;
else
success = !requestsByIdentifier.containsKey(id);
if(success) {
if(!persistent) {
try {
cp = new ClientPut(this, message, server);
requestsByIdentifier.put(id, cp);
} catch (IdentifierCollisionException e) {
success = false;
} catch (MessageInvalidException e) {
outputHandler.queue(new ProtocolErrorMessage(e.protocolCode, false, e.getMessage(), e.ident, e.global));
return;
} catch (MalformedURLException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, e.getMessage(), id, message.global);
} catch (IOException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.IO_ERROR, true, e.getMessage(), id, message.global);
}
} else if(message.persistence == Persistence.FOREVER) {
try {
server.core.clientContext.jobRunner.queue(new PersistentJob() {
@Override
public boolean run(ClientContext context) {
ClientPut putter;
try {
putter = new ClientPut(FCPConnectionHandler.this, message, server);
} catch (IdentifierCollisionException e) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, message.global);
outputHandler.queue(msg);
return false;
} catch (MessageInvalidException e) {
outputHandler.queue(new ProtocolErrorMessage(e.protocolCode, false, e.getMessage(), e.ident, e.global));
return false;
} catch (MalformedURLException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, null, id, message.global));
return false;
} catch (IOException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.IO_ERROR, true, null, id, message.global));
return false;
}
try {
putter.register(false);
} catch (IdentifierCollisionException e) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, global);
outputHandler.queue(msg);
return false;
}
putter.start(context);
return true;
}
}, NativeThread.HIGH_PRIORITY-1);
} catch (PersistenceDisabledException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.PERSISTENCE_DISABLED, false, "Persistence is disabled", id, global));
}
return; // Don't run the start() below
} else {
try {
cp = new ClientPut(this, message, server);
} catch (IdentifierCollisionException e) {
success = false;
} catch (MessageInvalidException e) {
outputHandler.queue(new ProtocolErrorMessage(e.protocolCode, false, e.getMessage(), e.ident, e.global));
return;
} catch (MalformedURLException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, null, id, message.global);
} catch (IOException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.IO_ERROR, true, null, id, message.global);
}
}
}
if(!success) {
Logger.normal(this, "Identifier collision on "+this);
failedMessage = new IdentifierCollisionMessage(id, message.global);
}
}
if(message.persistence == Persistence.REBOOT && cp != null)
try {
cp.register(false);
} catch (IdentifierCollisionException e) {
failedMessage = new IdentifierCollisionMessage(id, message.global);
}
if(failedMessage != null) {
if(logMINOR) Logger.minor(this, "Failed: "+failedMessage);
outputHandler.queue(failedMessage);
if(cp != null)
cp.freeData();
else
message.freeData();
return;
} else {
Logger.minor(this, "Starting "+cp);
cp.start(server.core.clientContext);
}
}
public void startClientPutDir(final ClientPutDirMessage message, final HashMap<String, Object> buckets, final boolean wasDiskPut) {
if(logMINOR)
Logger.minor(this, "Start ClientPutDir");
final String id = message.identifier;
final boolean global = message.global;
ClientPutDir cp = null;
FCPMessage failedMessage = null;
boolean persistent = message.persistence != Persistence.CONNECTION;
// We need to track non-persistent requests anyway, so we may as well check
boolean success;
synchronized(this) {
if(isClosed) return;
if(!persistent)
success = true;
else
success = !requestsByIdentifier.containsKey(id);
}
if(success) {
if(!persistent) {
try {
cp = new ClientPutDir(this, message, buckets, wasDiskPut, server);
synchronized(this) {
requestsByIdentifier.put(id, cp);
}
} catch (IdentifierCollisionException e) {
success = false;
} catch (MalformedURLException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, null, id, message.global);
} catch (TooManyFilesInsertException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.TOO_MANY_FILES_IN_INSERT, true, null, id, message.global);
}
// FIXME register non-persistent requests in the constructors also, we already register persistent ones...
} else if(message.persistence == Persistence.FOREVER) {
try {
server.core.clientContext.jobRunner.queue(new PersistentJob() {
@Override
public boolean run(ClientContext context) {
ClientPutDir putter;
try {
putter = new ClientPutDir(FCPConnectionHandler.this, message, buckets, wasDiskPut, server);
} catch (IdentifierCollisionException e) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, message.global);
outputHandler.queue(msg);
return false;
} catch (MalformedURLException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, null, id, message.global));
return false;
} catch (TooManyFilesInsertException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.TOO_MANY_FILES_IN_INSERT, true, null, id, message.global));
return false;
}
try {
putter.register(false);
} catch (IdentifierCollisionException e) {
Logger.normal(this, "Identifier collision on "+this);
FCPMessage msg = new IdentifierCollisionMessage(id, global);
outputHandler.queue(msg);
return false;
}
putter.start(context);
return true;
}
}, NativeThread.HIGH_PRIORITY-1);
} catch (PersistenceDisabledException e) {
outputHandler.queue(new ProtocolErrorMessage(ProtocolErrorMessage.PERSISTENCE_DISABLED, false, "Persistence is disabled", id, global));
}
return; // Don't run the start() below
} else {
try {
cp = new ClientPutDir(this, message, buckets, wasDiskPut, server);
} catch (IdentifierCollisionException e) {
success = false;
} catch (MalformedURLException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.FREENET_URI_PARSE_ERROR, true, null, id, message.global);
} catch (TooManyFilesInsertException e) {
failedMessage = new ProtocolErrorMessage(ProtocolErrorMessage.TOO_MANY_FILES_IN_INSERT, true, null, id, message.global);
}
}
if(!success) {
Logger.normal(this, "Identifier collision on "+this);
failedMessage = new IdentifierCollisionMessage(id, message.global);
}
}
if(message.persistence == Persistence.REBOOT)
try {
cp.register(false);
} catch (IdentifierCollisionException e) {
failedMessage = new IdentifierCollisionMessage(id, message.global);
}
if(failedMessage != null) {
// FIXME do we need to freeData???
outputHandler.queue(failedMessage);
if(cp != null)
cp.cancel(server.core.clientContext);
return;
} else {
if(logMINOR)
Logger.minor(this, "Starting "+cp);
cp.start(server.core.clientContext);
}
}
public PersistentRequestClient getRebootClient() {
return rebootClient;
}
/**
* @return
* The {@link FCPPluginConnection} for the given serverPluginName (see
* {@link PluginManager#getPluginFCPServer(String)}). Atomically creates and stores it if
* there does not exist one yet. This ensures that for each FCPConnectionHandler, there can
* be only one {@link FCPPluginConnection} for a given serverPluginName.
* @throws PluginNotFoundException
* If the specified plugin is not loaded or does not provide an FCP server.
*/
FCPPluginConnection getFCPPluginConnection(String serverPluginName)
throws PluginNotFoundException {
// The suspected typical usage pattern of this function is that the great majority of calls
// will return an existing FCPPluginConnection. Creating a fresh one will typically only
// happen at the start of a connection and then it will be re-used a lot.
// Therefore, it would cost a lot of performance to use synchronized() and we instead use a
// ReadWriteLock which is optimal for such patterns.
//
// The double-checked locking pattern which this induces is necessary due to the fact that a
// read-lock cannot be upgraded to a write lock.
// The JavaDoc of ReentrantReadWriteLock specifically recommends this pattern, so it ought
// to be a safe version of double-checked locking.
pluginConnectionsByServerName_Lock.readLock().lock();
try {
// We use the actual *Impl instead of the interface because the implementation provides
// isServerDead(), which the interface does not.
FCPPluginConnectionImpl peekOldConnection
= pluginConnectionsByServerName.get(serverPluginName);
if(peekOldConnection != null && !peekOldConnection.isServerDead()) {
return peekOldConnection;
}
} finally {
// A read-lock cannot be upgraded to a write-lock so we must always unlock
pluginConnectionsByServerName_Lock.readLock().unlock();
}
pluginConnectionsByServerName_Lock.writeLock().lock();
try {
// Re-check whether there is an existing connection since we had to re-acquire the lock
// meanwhile.
FCPPluginConnectionImpl oldConnection
= pluginConnectionsByServerName.get(serverPluginName);
if(oldConnection != null) {
if(!oldConnection.isServerDead()) {
return oldConnection;
} else {
// oldConnection.isDead() returned true because the WeakReference to the server
// has been nulled because the plugin was unloaded or reloaded.
// The connection should be discarded then. We have no ReferenceQueue to discard
// affected connections from the pluginConnectionsByServerName table, so we
// opportunistically clean nulled connections from it here.
// The reason why this is sufficient memory management is explained at
// FCPPluginConnectionImpl.server
// NOTICE: Even if there was automatic disposal of nulled references, we still
// would have to manually remove dead ones here: I have observed that it can
// take minutes until the JVM flushes a ReferenceQueue. So if we relied upon
// that only, during those minutes a client would be unable to send messages to
// a re-loaded server plugin because the continued existence of the dead old
// connection would prevent a new one from being created.
pluginConnectionsByServerName.remove(serverPluginName);
}
}
FCPPluginConnectionImpl newConnection
= server.createFCPPluginConnectionForNetworkedFCP(serverPluginName, this);
pluginConnectionsByServerName.put(serverPluginName, newConnection);
return newConnection;
} finally {
pluginConnectionsByServerName_Lock.writeLock().unlock();
}
}
public PersistentRequestClient getForeverClient() {
synchronized(this) {
if(foreverClient == null) {
foreverClient = createForeverClient(clientName);
}
return foreverClient;
}
}
public void finishedClientRequest(ClientRequest get) {
synchronized(this) {
requestsByIdentifier.remove(get.getIdentifier());
}
}
public boolean isGlobalSubscribed() {
return rebootClient.watchGlobal;
}
public boolean hasFullAccess() {
return server.allowedHostsFullAccess.allowed(sock.getInetAddress());
}
/**
* That method ought to be called before any DirectDiskAccess operation is performed by the node
* @param filename
* @param writeRequest : Are willing to write or to read ?
* @return boolean : allowed or not
*/
protected boolean allowDDAFrom(File filename, boolean writeRequest) {
String parentDirectory = FileUtil.getCanonicalFile(filename).getParent();
DirectoryAccess da = null;
synchronized (checkedDirectories) {
da = checkedDirectories.get(parentDirectory);
}
if(logMINOR)
Logger.minor(this, "Checking DDA: "+da+" for "+parentDirectory);
if(writeRequest)
return (da == null ? server.isDownloadDDAAlwaysAllowed() : da.canWrite);
else
return (da == null ? server.isUploadDDAAlwaysAllowed() : da.canRead);
}
/**
* SHOULD BE CALLED ONLY FROM TestDDAComplete!
* @param path
* @param read
* @param write
*/
protected void registerTestDDAResult(String path, boolean read, boolean write) {
DirectoryAccess da = new DirectoryAccess(read, write);
synchronized (checkedDirectories) {
checkedDirectories.put(path, da);
}
if(logMINOR)
Logger.minor(this, "DDA: read="+read+" write="+write+" for "+path);
}
/**
* Return a DDACheckJob : the one we created and have enqueued
* @param path
* @param read : is Read access requested ?
* @param write : is Write access requested ?
* @return
* @throws IllegalArgumentException
*
* FIXME: Maybe we need to enqueue a PS job to delete the created file after something like ... 5 mins ?
*/
protected DDACheckJob enqueueDDACheck(String path, boolean read, boolean write) throws IllegalArgumentException {
File directory = FileUtil.getCanonicalFile(new File(path));
if(!directory.exists() || !directory.isDirectory())
throw new IllegalArgumentException("The specified path isn't a directory! or doesn't exist or the node doesn't have access to it!");
// See #1856
DDACheckJob job = null;
synchronized (inTestDirectories) {
job = inTestDirectories.get(directory);
}
if(job != null)
throw new IllegalArgumentException("There is already a TestDDA going on for that directory!");
File writeFile = (write ? new File(path, "DDACheck-" + server.node.fastWeakRandom.nextInt() + ".tmp") : null);
File readFile = null;
if(read) {
try {
readFile = File.createTempFile("DDACheck-", ".tmp", directory);
readFile.deleteOnExit();
} catch (IOException e) {
// Now we know it: we can't write there ;)
readFile = null;
}
}
DDACheckJob result = new DDACheckJob(server.node.fastWeakRandom, directory, readFile, writeFile);
synchronized (inTestDirectories) {
inTestDirectories.put(directory, result);
}
if(read && (readFile != null) && readFile.canWrite()){
// We don't want to attempt to write before: in case an IOException is raised, we want to inform the
// client somehow that the node can't write there... And setting readFile to null means we won't inform
// it on the status (as if it hadn't requested us to do the test).
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
fos = new FileOutputStream(result.readFilename);
bos = new BufferedOutputStream(fos);
bos.write(result.readContent.getBytes("UTF-8"));
bos.flush();
} catch (IOException e) {
Logger.error(this, "Got a IOE while creating the file (" + readFile.toString() + " ! " + e.getMessage());
} finally {
Closer.close(bos);
Closer.close(fos);
}
}
return result;
}
/**
* Return a DDACheckJob or null if not found
* @param path
* @return the DDACheckJob
* @throws IllegalArgumentException
*/
protected DDACheckJob popDDACheck(String path) throws IllegalArgumentException {
File directory = FileUtil.getCanonicalFile(new File(path));
if(!directory.exists() || !directory.isDirectory())
throw new IllegalArgumentException("The specified path isn't a directory! or doesn't exist or the node doesn't have access to it!");
synchronized (inTestDirectories) {
return inTestDirectories.remove(directory);
}
}
/**
* Delete the files we have created using DDATest
* called by PersistentRequestClient.onDisconnect(handler)
*/
protected void freeDDAJobs(){
synchronized (inTestDirectories) {
for(DDACheckJob job: inTestDirectories.values()) {
if (job.readFilename != null)
job.readFilename.delete();
}
}
}
public ClientRequest removeRequestByIdentifier(String identifier, boolean kill) {
ClientRequest req;
synchronized(this) {
req = requestsByIdentifier.remove(identifier);
}
if(req != null) {
if(kill)
req.cancel(server.core.clientContext);
req.requestWasRemoved(server.core.clientContext);
}
return req;
}
ClientRequest getRebootRequest(boolean global, FCPConnectionHandler handler, String identifier) {
if(global)
return handler.server.globalRebootClient.getRequest(identifier);
else
return handler.getRebootClient().getRequest(identifier);
}
ClientRequest getForeverRequest(boolean global, FCPConnectionHandler handler, String identifier) {
if(global)
return handler.server.globalForeverClient.getRequest(identifier);
else
return handler.getForeverClient().getRequest(identifier);
}
ClientRequest removePersistentRebootRequest(boolean global, String identifier) throws MessageInvalidException {
PersistentRequestClient client =
global ? server.globalRebootClient :
getRebootClient();
ClientRequest req = client.getRequest(identifier);
if(req != null) {
client.removeByIdentifier(identifier, true, server, server.core.clientContext);
}
return req;
}
ClientRequest removePersistentForeverRequest(boolean global, String identifier) throws MessageInvalidException {
PersistentRequestClient client =
global ? server.globalForeverClient :
getForeverClient();
ClientRequest req = client.getRequest(identifier);
if(req != null) {
client.removeByIdentifier(identifier, true, server, server.core.clientContext);
}
return req;
}
public synchronized void addUSKSubscription(String identifier, SubscribeUSK subscribeUSK) throws IdentifierCollisionException {
if(uskSubscriptions.containsKey(identifier)) throw new IdentifierCollisionException();
uskSubscriptions.put(identifier, subscribeUSK);
}
public void unsubscribeUSK(String identifier) throws MessageInvalidException {
SubscribeUSK sub;
synchronized(this) {
sub = uskSubscriptions.remove(identifier);
if(sub == null) throw new MessageInvalidException(ProtocolErrorMessage.NO_SUCH_IDENTIFIER, "No such identifier unsubscribing", identifier, false);
}
sub.unsubscribe();
}
public RequestClient connectionRequestClient(boolean realTime) {
if(realTime)
return connectionRequestClientRT;
else
return connectionRequestClientBulk;
}
}