Remove tryLockForReading/Writing methods from FileKeyLockManager

With respect to incorporating IoPolicy, the semantics of these methods
are not clear. (Did we not get a lock because locking is broken for the
file system, or because someone else already holds a write lock?)

These methods were only used in tests. For simplicity, we just remove
them for now.

Author: tpietzsch

src/main/java/org/janelia/saalfeldlab/n5/FileKeyLockManager.java

@@ -135,30 +135,6 @@ public LockedFileChannel lockForWriting(final Path path) throws IOException {
 		return keyLockState(path).acquireWrite();
 	}
 
-	/**
-	 * Attempts to acquire a read lock for the specified key without blocking.
-	 *
-	 * @param path
-	 *            the file path to lock for reading
-	 * @return a {@link LockedChannel} if the lock was acquired, null otherwise
-	 */
-	public LockedFileChannel tryLockForReading(final Path path) {
-
-		return keyLockState(path).tryAcquireRead();
-	}
-
-	/**
-	 * Attempts to acquire a write lock for the specified key without blocking.
-	 *
-	 * @param path
-	 *            the file path to lock for writing
-	 * @return a {@link LockedChannel} if the lock was acquired, null otherwise
-	 */
-	public LockedFileChannel tryLockForWriting(final Path path) {
-
-		return keyLockState(path).tryAcquireWrite();
-	}
-
 	/**
 	 * Returns the number of keys currently being tracked.
 	 *

src/main/java/org/janelia/saalfeldlab/n5/KeyLockState.java

@@ -85,56 +85,6 @@ LockedFileChannel acquireRead() throws IOException {
 		}
 	}
 
-	LockedFileChannel tryAcquireRead() {
-
-		if(!readerMutex.tryAcquire()) {
-			return null;
-		}
-
-		try {
-			if (numReaders == 0) {
-				// We are the first Reader, and are responsible for creating the channelLock
-				// (Other concurrent Readers are still blocked in readerMutex.)
-
-				// If a Writer is still open, this will fail
-				if(!channelLockMutex.tryAcquire()) {
-					return null;
-				}
-
-				try {
-					channelLock = ChannelLock.tryLock(path, false);
-				} catch (IOException e) {
-					// Something went wrong. Back off.
-					channelLockMutex.release();
-					return null;
-				}
-			}
-
-			// We have a READ ChannelLock.
-			// Try to open a FileChannel.
-			final FileChannel channel;
-			try {
-				channel = FileChannel.open(path, StandardOpenOption.READ);
-			} catch (final IOException e) {
-				// Something went wrong. Back off.
-				if (numReaders == 0) {
-					try {
-						releaseChannelLock();
-					} catch (IOException ignored) {
-					}
-				}
-				return null;
-			}
-
-			// We have a FileChannel.
-			// Create a LockedFileChannel that will releaseRead() when it is closed.
-			++numReaders;
-			return new LockedFileChannel(channel, this::releaseRead);
-		} finally {
-			readerMutex.release();
-		}
-	}
-
 	void releaseRead() throws IOException {
 
 		try {
@@ -184,25 +134,6 @@ LockedFileChannel acquireWrite() throws IOException {
 		}
 	}
 
-	LockedFileChannel tryAcquireWrite() {
-
-		if (!channelLockMutex.tryAcquire()) {
-			return null;
-		}
-
-		try {
-			channelLock = ChannelLock.tryLock(path, true);
-		} catch (IOException e) {
-			// Something went wrong. Back off.
-			channelLockMutex.release();
-			return null;
-		}
-
-		// We have a WRITE ChannelLock.
-		// Create a LockedFileChannel that will releaseWrite() when it is closed.
-		return new LockedFileChannel(channelLock.getChannel(), this::releaseWrite);
-	}
-
 	void releaseWrite() throws IOException {
 		releaseChannelLock();
 	}

src/test/java/org/janelia/saalfeldlab/n5/FileKeyLockManagerTest.java

@@ -33,13 +33,15 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
 import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
@@ -194,66 +196,6 @@ public void testReadWriteExclusion() throws Exception {
 		assertEquals("Reader should see written content", writtenContent, readContent.get());
 	}
 
-	@Test
-	public void testTryLock() throws Exception {
-
-		/* create a test file */
-		final Path testFile = tempDir.resolve("test3.txt");
-		final String testContent = "test content";
-		Files.write(testFile, testContent.getBytes());
-
-		/* try acquiring read lock and read */
-		LockedChannel readLock1 = FILE_LOCK_MANAGER.tryLockForReading(testFile);
-		assertNotNull("Should acquire read lock", readLock1);
-		try (final Reader reader = readLock1.newReader()) {
-			final char[] buf = new char[testContent.length()];
-			assertEquals("Should read correct number of chars", testContent.length(), reader.read(buf));
-		}
-
-		/* try acquiring another read lock and read */
-		LockedChannel readLock2 = FILE_LOCK_MANAGER.tryLockForReading(testFile);
-		assertNotNull("Should acquire second read lock", readLock2);
-		try (final Reader reader = readLock2.newReader()) {
-			final char[] buf = new char[testContent.length()];
-			assertEquals("Should read correct number of chars", testContent.length(), reader.read(buf));
-		}
-
-		/* try acquiring write lock while reads are held - should fail */
-		LockedChannel writeLock = FILE_LOCK_MANAGER.tryLockForWriting(testFile);
-		assertNull("Should not acquire write lock while reads are held", writeLock);
-
-		readLock1.close();
-		readLock2.close();
-
-		/* now try write lock and write */
-		writeLock = FILE_LOCK_MANAGER.tryLockForWriting(testFile);
-		assertNotNull("Should acquire write lock after reads are released", writeLock);
-		final String newContent = "new content";
-		try (final Writer writer = writeLock.newWriter()) {
-			writer.write(newContent);
-		}
-
-		/* try acquiring read lock from another thread while write is held */
-		final AtomicReference<LockedChannel> readLock3 = new AtomicReference<>();
-		final Thread readerThread = new Thread(() -> {
-			readLock3.set(FILE_LOCK_MANAGER.tryLockForReading(testFile));
-		});
-		readerThread.start();
-		readerThread.join();
-
-		assertNull("Should not acquire read lock while write is held", readLock3.get());
-
-		writeLock.close();
-
-		/* verify written content */
-		try (final LockedChannel verifyLock = FILE_LOCK_MANAGER.lockForReading(testFile);
-			 final Reader reader = verifyLock.newReader()) {
-			final char[] buf = new char[newContent.length()];
-			reader.read(buf);
-			assertEquals("Content should match what was written", newContent, new String(buf));
-		}
-	}
-
 	private class CleanUpHelper implements Closeable
 	{
 		private final Path path;
@@ -391,8 +333,7 @@ public void testWriteLockCreatesParentDirectories() throws Exception {
 	@Test
 	public void testReadLockRequiresExistingFile() throws Exception {
 		final Path testFile = tempDir.resolve("nonexistent.txt");
-		assertNull("Should not acquire read lock for non-existent file",
-				FILE_LOCK_MANAGER.tryLockForReading(testFile));
+		assertThrows("Should not acquire read lock for non-existent file", NoSuchFileException.class, () -> FILE_LOCK_MANAGER.lockForReading(testFile));
 	}
 
 	@Test