Implemented truncate

Author: markuskreusch

src/main/java/org/cryptomator/cryptofs/ChunkData.java

@@ -38,6 +38,13 @@ public boolean wasWritten() {
 		return written;
 	}
 
+	public void truncate(int length) {
+		if (this.length > length) {
+			this.length = length;
+			this.written = true;
+		}
+	}
+
 	public CopyWithoutDirection copyData() {
 		return copyDataStartingAt(0);
 	}

src/main/java/org/cryptomator/cryptofs/OpenCryptoFile.java

@@ -12,6 +12,7 @@
 import static java.lang.Math.min;
 import static org.cryptomator.cryptofs.OpenCounter.OpenState.ALREADY_CLOSED;
 import static org.cryptomator.cryptofs.OpenCounter.OpenState.WAS_OPEN;
+import static org.cryptomator.cryptolib.Cryptors.ciphertextSize;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -51,8 +52,6 @@ public OpenCryptoFile(EffectiveOpenOptions options, Cryptor cryptor, FileChannel
 		this.header = header;
 		this.size = size;
 		this.stats = stats;
-
-		size.set(header.getFilesize());
 	}
 
 	public FileChannel newFileChannel(EffectiveOpenOptions options) throws IOException {
@@ -135,13 +134,22 @@ public long size() {
 	}
 
 	public synchronized void truncate(long size) throws IOException {
-		// TODO
+		long originalSize = this.size.getAndUpdate(current -> min(size, current));
+		if (originalSize > size) {
+			int cleartextChunkSize = cryptor.fileContentCryptor().cleartextChunkSize();
+			long indexOfLastChunk = (size + cleartextChunkSize - 1) / cleartextChunkSize - 1;
+			int sizeOfIncompleteChunk = (int) (size % cleartextChunkSize);
+			if (sizeOfIncompleteChunk > 0) {
+				chunkCache.get(indexOfLastChunk).truncate(sizeOfIncompleteChunk);
+			}
+			long ciphertextFileSize = cryptor.fileHeaderCryptor().headerSize() + ciphertextSize(size, cryptor);
+			channel.truncate(ciphertextFileSize);
+		}
 	}
 
 	public synchronized void force(boolean metaData, EffectiveOpenOptions options) throws IOException {
 		chunkCache.invalidateAll(); // TODO increase performance by writing chunks but keeping them cached
 		if (options.writable()) {
-			header.setFilesize(size.get());
 			channel.write(cryptor.fileHeaderCryptor().encryptHeader(header), 0);
 		}
 		channel.force(metaData);

src/main/java/org/cryptomator/cryptofs/OpenCryptoFileFactoryModule.java

@@ -1,6 +1,7 @@
 package org.cryptomator.cryptofs;
 
 import static org.cryptomator.cryptofs.UncheckedThrows.rethrowUnchecked;
+import static org.cryptomator.cryptolib.Cryptors.cleartextSize;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -26,8 +27,16 @@ public FileChannel provideFileChannel(@OpenFilePath Path path, EffectiveOpenOpti
 	@Provides
 	@PerOpenFile
 	@OpenFileSize
-	public AtomicLong provideFileSize() {
-		return new AtomicLong();
+	public AtomicLong provideFileSize(FileChannel channel, Cryptor cryptor) {
+		return rethrowUnchecked(IOException.class).from(() -> {
+			long size = channel.size();
+			if (size == 0) {
+				return new AtomicLong();
+			} else {
+				int headerSize = cryptor.fileHeaderCryptor().headerSize();
+				return new AtomicLong(cleartextSize(size - headerSize, cryptor));
+			}
+		});
 	}
 
 	@Provides

src/main/java/org/cryptomator/cryptofs/PatternPathMatcher.java

@@ -12,6 +12,14 @@ public PatternPathMatcher(Pattern pattern) {
 		this.pattern = pattern;
 	}
 
+	/**
+	 * @deprecated for testing
+	 */
+	@Deprecated
+	Pattern getPattern() {
+		return pattern;
+	}
+
 	@Override
 	public boolean matches(Path path) {
 		return pattern.matcher(path.toString()).matches();

src/test/java/org/cryptomator/cryptofs/CryptoFileChannelWriteReadIntegrationTest.java

@@ -8,6 +8,7 @@
  *******************************************************************************/
 package org.cryptomator.cryptofs;
 
+import static java.lang.Math.min;
 import static java.lang.String.format;
 import static java.nio.file.StandardOpenOption.APPEND;
 import static java.nio.file.StandardOpenOption.CREATE;
@@ -88,6 +89,38 @@ public void testWriteAndReadNothing() throws IOException {
 		}
 	}
 
+	@Theory
+	public void testWriteDataAndTruncateToOffset(@FromDataPoints("dataSizes") int cleartextSize, @FromDataPoints("writeOffsets") int truncateToSize) throws IOException {
+		long fileId = nextFileId();
+
+		int targetSize = min(truncateToSize, cleartextSize);
+
+		try (FileChannel channel = writableChannel(fileId)) {
+			assertEquals(0, channel.size());
+			channel.write(repeat(1).times(cleartextSize).asByteBuffer());
+			assertEquals(cleartextSize, channel.size());
+		}
+
+		try (FileChannel channel = writableChannel(fileId)) {
+			assertEquals(cleartextSize, channel.size());
+			channel.truncate(truncateToSize);
+			assertEquals(targetSize, channel.size());
+		}
+
+		try (FileChannel channel = readableChannel(fileId)) {
+			if (targetSize > 0) {
+				ByteBuffer buffer = ByteBuffer.allocate(targetSize);
+				int result = channel.read(buffer);
+				assertEquals(targetSize, result);
+				buffer.flip();
+				for (int i = 0; i < targetSize; i++) {
+					assertEquals(format("byte(%d) = 1", i), 1, buffer.get(i));
+				}
+			}
+			assertEquals(EOF, channel.read(ByteBuffer.allocate(0)));
+		}
+	}
+
 	@Theory
 	public void testWithWritingOffset(@FromDataPoints("dataSizes") int dataSize, @FromDataPoints("writeOffsets") int writeOffset) throws IOException {
 		assumeTrue(dataSize != 0 || writeOffset != 0);

src/test/java/org/cryptomator/cryptofs/PathMatcherFactoryTest.java

@@ -0,0 +1,66 @@
+package org.cryptomator.cryptofs;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.nio.file.PathMatcher;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+public class PathMatcherFactoryTest {
+
+	@Rule
+	public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	private GlobToRegexConverter globToRegexConverter = mock(GlobToRegexConverter.class);
+
+	private PathMatcherFactory inTest = new PathMatcherFactory(globToRegexConverter);
+
+	@Test
+	public void testSyntaxAndPatternNotStartingWithGlobOrRegexThrowsUnsupportedOperationException() {
+		thrown.expect(UnsupportedOperationException.class);
+
+		inTest.pathMatcherFrom("fail");
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	public void testSyntaxAndPatternStartingWithRegexCreatesPatternPathMatcherWithCorrectPattern() {
+		PathMatcher pathMatcher = inTest.pathMatcherFrom("regex:test[02]");
+
+		assertThat(pathMatcher, is(instanceOf(PatternPathMatcher.class)));
+		assertThat(((PatternPathMatcher) pathMatcher).getPattern().pattern(), is("test[02]"));
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	public void testSyntaxAndPatternStartingWithGlobCreatesPatternPathMatcherWithCorrectPattern() {
+		String regexp = "test[abcd]*";
+		when(globToRegexConverter.convert("abcd")).thenReturn(regexp);
+
+		PathMatcher pathMatcher = inTest.pathMatcherFrom("glob:abcd");
+
+		assertThat(pathMatcher, is(instanceOf(PatternPathMatcher.class)));
+		assertThat(((PatternPathMatcher) pathMatcher).getPattern().pattern(), is(regexp));
+	}
+
+	@Test
+	public void testSyntaxAndPatternIgnoresCase() {
+		when(globToRegexConverter.convert(anyString())).thenReturn("a");
+
+		inTest.pathMatcherFrom("reGEx:a");
+		inTest.pathMatcherFrom("gLOb:a");
+	}
+
+}