Merge branch 'develop'

charphi · charphi · commit 74e7d5f83ced · 2023-07-18T15:36:52.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,12 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.0.25] - 2023-07-18
+
+### Fixed
+
+- Fix OverlappingFileLockException
+
 ## [0.0.24] - 2023-06-30
 
 ### Added
@@ -224,7 +230,8 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - Initial release
 
-[Unreleased]: https://github.com/nbbrd/java-io-util/compare/v0.0.24...HEAD
+[Unreleased]: https://github.com/nbbrd/java-io-util/compare/v0.0.25...HEAD
+[0.0.25]: https://github.com/nbbrd/java-io-util/compare/v0.0.24...v0.0.25
 [0.0.24]: https://github.com/nbbrd/java-io-util/compare/v0.0.23...v0.0.24
 [0.0.23]: https://github.com/nbbrd/java-io-util/compare/v0.0.22...v0.0.23
 [0.0.22]: https://github.com/nbbrd/java-io-util/compare/v0.0.21...v0.0.22
diff --git a/java-io-base/pom.xml b/java-io-base/pom.xml
@@ -5,7 +5,7 @@
     <parent>
         <groupId>com.github.nbbrd.java-io-util</groupId>
         <artifactId>java-io-parent</artifactId>
-        <version>0.0.24</version>
+        <version>0.0.25</version>
     </parent>
 
     <artifactId>java-io-base</artifactId>
diff --git a/java-io-base/src/main/java/internal/io/DecodingFileParser.java b/java-io-base/src/main/java/internal/io/DecodingFileParser.java
@@ -13,7 +13,7 @@
 import static nbbrd.io.Resource.uncloseableInputStream;
 
 @lombok.RequiredArgsConstructor
-public final class DecodingFileFormatter<T> implements FileParser<T> {
+public final class DecodingFileParser<T> implements FileParser<T> {
 
     @NonNull
     final FileParser<T> parser;
diff --git a/java-io-base/src/main/java/internal/io/InternalResource.java b/java-io-base/src/main/java/internal/io/InternalResource.java
@@ -0,0 +1,26 @@
+package internal.io;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+@lombok.experimental.UtilityClass
+public class InternalResource {
+
+    public static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    public static byte[] readAllBytes(InputStream stream) throws IOException {
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        transferTo(stream, result);
+        return result.toByteArray();
+    }
+
+    public static void transferTo(InputStream input, OutputStream output) throws IOException {
+        byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
+        int read;
+        while ((read = input.read(buffer, 0, DEFAULT_BUFFER_SIZE)) >= 0) {
+            output.write(buffer, 0, read);
+        }
+    }
+}
diff --git a/java-io-base/src/main/java/internal/io/LockingFileFormatter.java b/java-io-base/src/main/java/internal/io/LockingFileFormatter.java
@@ -2,6 +2,7 @@
 
 import lombok.NonNull;
 import nbbrd.io.FileFormatter;
+import nbbrd.io.WrappedIOException;
 import nbbrd.io.function.IOSupplier;
 
 import java.io.File;
@@ -11,6 +12,7 @@
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileLock;
+import java.nio.channels.OverlappingFileLockException;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 
@@ -26,6 +28,8 @@ public void formatFile(@NonNull T value, @NonNull File target) throws IOExceptio
         try (FileOutputStream stream = new FileOutputStream(checkTarget(target))) {
             try (FileLock ignore = stream.getChannel().lock()) {
                 delegate.formatStream(value, stream);
+            } catch (OverlappingFileLockException ex) {
+                throw WrappedIOException.wrap(ex);
             }
         }
     }
@@ -35,6 +39,8 @@ public void formatPath(@NonNull T value, @NonNull Path target) throws IOExceptio
         try (FileChannel channel = FileChannel.open(checkTarget(target), StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
             try (FileLock ignore = channel.lock()) {
                 delegate.formatStream(value, Channels.newOutputStream(channel));
+            } catch (OverlappingFileLockException ex) {
+                throw WrappedIOException.wrap(ex);
             }
         }
     }
diff --git a/java-io-base/src/main/java/internal/io/LockingFileParser.java b/java-io-base/src/main/java/internal/io/LockingFileParser.java
@@ -2,6 +2,7 @@
 
 import lombok.NonNull;
 import nbbrd.io.FileParser;
+import nbbrd.io.WrappedIOException;
 import nbbrd.io.function.IOSupplier;
 
 import java.io.File;
@@ -11,6 +12,7 @@
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileLock;
+import java.nio.channels.OverlappingFileLockException;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 
@@ -26,6 +28,8 @@ public final class LockingFileParser<T> implements FileParser<T> {
         try (FileInputStream stream = new FileInputStream(checkSource(source))) {
             try (FileLock ignore = stream.getChannel().lock(0, Long.MAX_VALUE, true)) {
                 return delegate.parseStream(stream);
+            } catch (OverlappingFileLockException ex) {
+                throw WrappedIOException.wrap(ex);
             }
         }
     }
@@ -35,6 +39,8 @@ public final class LockingFileParser<T> implements FileParser<T> {
         try (FileChannel channel = FileChannel.open(checkSource(source), StandardOpenOption.READ)) {
             try (FileLock ignore = channel.lock(0, Long.MAX_VALUE, true)) {
                 return delegate.parseStream(Channels.newInputStream(channel));
+            } catch (OverlappingFileLockException ex) {
+                throw WrappedIOException.wrap(ex);
             }
         }
     }
diff --git a/java-io-base/src/main/java/module-info.java b/java-io-base/src/main/java/module-info.java
@@ -28,5 +28,6 @@
     exports nbbrd.io.text;
     exports nbbrd.io.zip;
 
+    exports internal.io to nbbrd.io.xml, nbbrd.io.xml.bind, nbbrd.io.picocsv;
     exports internal.io.text to nbbrd.io.xml, nbbrd.io.xml.bind, nbbrd.io.picocsv;
 }
diff --git a/java-io-base/src/main/java/nbbrd/io/FileParser.java b/java-io-base/src/main/java/nbbrd/io/FileParser.java
@@ -1,7 +1,7 @@
 package nbbrd.io;
 
 import internal.io.AndThenFileParser;
-import internal.io.DecodingFileFormatter;
+import internal.io.DecodingFileParser;
 import internal.io.FunctionalFileParser;
 import internal.io.LockingFileParser;
 import internal.io.text.LegacyFiles;
@@ -58,7 +58,7 @@ public interface FileParser<T> {
 
     @StaticFactoryMethod
     static <T> @NonNull FileParser<T> onParsingGzip(@NonNull FileParser<T> parser) {
-        return new DecodingFileFormatter<>(parser, GZIPInputStream::new);
+        return new DecodingFileParser<>(parser, GZIPInputStream::new);
     }
 
     @StaticFactoryMethod
diff --git a/java-io-base/src/main/java/nbbrd/io/zip/Zip.java b/java-io-base/src/main/java/nbbrd/io/zip/Zip.java
@@ -16,6 +16,7 @@
  */
 package nbbrd.io.zip;
 
+import internal.io.InternalResource;
 import lombok.NonNull;
 import nbbrd.io.Resource;
 import nbbrd.io.function.IOPredicate;
@@ -99,12 +100,8 @@ private byte[] toByteArray(ZipEntry entry, ZipInputStream stream) throws IOExcep
         if (size >= Integer.MAX_VALUE) {
             throw new IOException("ZIP entry size is too large");
         }
-        ByteArrayOutputStream result = new ByteArrayOutputStream(size > 0 ? (int) size : 4096);
-        byte[] buffer = new byte[4096];
-        int len;
-        while ((len = stream.read(buffer)) != -1) {
-            result.write(buffer, 0, len);
-        }
+        ByteArrayOutputStream result = new ByteArrayOutputStream(size > 0 ? (int) size : InternalResource.DEFAULT_BUFFER_SIZE);
+        InternalResource.transferTo(stream, result);
         return result.toByteArray();
     }
 }
diff --git a/java-io-base/src/test/java/_test/io/ResourceId.java b/java-io-base/src/test/java/_test/io/ResourceId.java
@@ -1,9 +1,13 @@
 package _test.io;
 
+import internal.io.InternalResource;
 import internal.io.text.InternalTextResource;
 import lombok.NonNull;
 
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -34,15 +38,9 @@ public Path copyTo(Path temp) throws IOException {
     }
 
     public byte[] toBytes() throws IOException {
-        ByteArrayOutputStream result = new ByteArrayOutputStream();
         try (InputStream input = open()) {
-            byte[] buffer = new byte[8192];
-            int read;
-            while ((read = input.read(buffer, 0, buffer.length)) >= 0) {
-                result.write(buffer, 0, read);
-            }
+            return InternalResource.readAllBytes(input);
         }
-        return result.toByteArray();
     }
 
     public BufferedReader open(Charset encoding) throws IOException {
diff --git a/java-io-base/src/test/java/_test/io/Util.java b/java-io-base/src/test/java/_test/io/Util.java
@@ -1,16 +1,25 @@
 package _test.io;
 
+import internal.io.InternalResource;
 import nbbrd.io.Resource;
+import nbbrd.io.WrappedIOException;
+import nbbrd.io.function.IORunnable;
 import nbbrd.io.function.IOSupplier;
 import nbbrd.io.function.IOUnaryOperator;
 import nbbrd.io.sys.SystemProperties;
+import org.assertj.core.api.Condition;
 
 import java.io.*;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileTime;
+import java.util.List;
+import java.util.Objects;
 import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+import static java.util.stream.Collectors.toList;
 
 public final class Util {
 
@@ -70,14 +79,28 @@ public static byte[] encode(byte[] bytes, IOUnaryOperator<OutputStream> encoder)
     }
 
     public static byte[] decode(byte[] bytes, IOUnaryOperator<InputStream> encoder) throws IOException {
-        ByteArrayOutputStream result = new ByteArrayOutputStream();
         try (InputStream input = encoder.applyWithIO(new ByteArrayInputStream(bytes))) {
-            byte[] buffer = new byte[8192];
-            int read;
-            while ((read = input.read(buffer, 0, buffer.length)) >= 0) {
-                result.write(buffer, 0, read);
-            }
+            return InternalResource.readAllBytes(input);
         }
-        return result.toByteArray();
+    }
+
+
+    public static Condition<Throwable> wrappedIOExceptionOfType(Class<?> type) {
+        return new Condition<>((Throwable o) -> o instanceof WrappedIOException && type.isInstance(o.getCause()), "");
+    }
+
+    public static List<Throwable> running(int n, IORunnable runnable) {
+        return IntStream.range(0, n)
+                .parallel()
+                .mapToObj(i -> {
+                    try {
+                        runnable.runWithIO();
+                    } catch (Throwable ex) {
+                        return ex;
+                    }
+                    return null;
+                })
+                .filter(Objects::nonNull)
+                .collect(toList());
     }
 }
diff --git a/java-io-base/src/test/java/internal/io/DecodingFileParserTest.java b/java-io-base/src/test/java/internal/io/DecodingFileParserTest.java
@@ -13,13 +13,13 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class DecodingFileFormatterTest {
+public class DecodingFileParserTest {
 
     @Test
     public void testClosing(@TempDir Path temp) throws IOException {
         AtomicInteger closeCount = new AtomicInteger(0);
 
-        DecodingFileFormatter<String> x = new DecodingFileFormatter<>(
+        DecodingFileParser<String> x = new DecodingFileParser<>(
                 FileParser.onParsingStream((stream) -> "hello"),
                 o -> new ForwardingInputStream(o).onClose(closeCount::incrementAndGet)
         );
@@ -36,7 +36,7 @@ public void testClosing(@TempDir Path temp) throws IOException {
         x.parseStream(() -> new ByteArrayInputStream(new byte[0]));
         assertThat(closeCount).hasValue(4);
 
-        x.parseResource(DecodingFileFormatter.class, "/nbbrd/io/text/hello.txt");
+        x.parseResource(DecodingFileParser.class, "/nbbrd/io/text/hello.txt");
         assertThat(closeCount).hasValue(5);
     }
 }
diff --git a/java-io-base/src/test/java/internal/io/LockingFileFormatterTest.java b/java-io-base/src/test/java/internal/io/LockingFileFormatterTest.java
@@ -0,0 +1,41 @@
+package internal.io;
+
+import _test.io.Util;
+import nbbrd.io.FileFormatter;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.file.Path;
+
+import static _test.io.Util.running;
+import static _test.io.Util.wrappedIOExceptionOfType;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LockingFileFormatterTest {
+
+    @Test
+    public void testOverlappingFileLockException(@TempDir Path temp) throws IOException {
+
+        LockingFileFormatter<String> x = new LockingFileFormatter<>(
+                FileFormatter.onFormattingStream((value, stream) -> {
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    stream.write(value.getBytes(UTF_8));
+                })
+        );
+
+        Path file = Util.newFile(temp);
+
+        assertThat(running(10, () -> x.formatFile("hello", file.toFile())))
+                .have(wrappedIOExceptionOfType(OverlappingFileLockException.class));
+
+        assertThat(running(10, () -> x.formatPath("hello", file)))
+                .have(wrappedIOExceptionOfType(OverlappingFileLockException.class));
+    }
+}
diff --git a/java-io-base/src/test/java/internal/io/LockingFileParserTest.java b/java-io-base/src/test/java/internal/io/LockingFileParserTest.java
@@ -0,0 +1,44 @@
+package internal.io;
+
+import _test.io.Util;
+import nbbrd.io.FileParser;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+
+import static _test.io.Util.running;
+import static _test.io.Util.wrappedIOExceptionOfType;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LockingFileParserTest {
+
+    @Test
+    public void testOverlappingFileLockException(@TempDir Path temp) throws IOException {
+
+        LockingFileParser<String> x = new LockingFileParser<>(
+                FileParser.onParsingStream((stream) -> {
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    return new String(InternalResource.readAllBytes(stream), UTF_8);
+                })
+        );
+
+        Path file = Util.newFile(temp);
+        Files.write(file, Collections.singleton("hello"));
+
+        assertThat(running(10, () -> x.parseFile(file.toFile())))
+                .have(wrappedIOExceptionOfType(OverlappingFileLockException.class));
+
+        assertThat(running(10, () -> x.parsePath(file)))
+                .have(wrappedIOExceptionOfType(OverlappingFileLockException.class));
+    }
+}
diff --git a/java-io-bom/pom.xml b/java-io-bom/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <artifactId>java-io-parent</artifactId>
         <groupId>com.github.nbbrd.java-io-util</groupId>
-        <version>0.0.24</version>
+        <version>0.0.25</version>
     </parent>
 
     <artifactId>java-io-bom</artifactId>
diff --git a/java-io-curl/pom.xml b/java-io-curl/pom.xml
diff --git a/java-io-picocsv/pom.xml b/java-io-picocsv/pom.xml
diff --git a/java-io-win/pom.xml b/java-io-win/pom.xml
diff --git a/java-io-xml-bind/pom.xml b/java-io-xml-bind/pom.xml
diff --git a/java-io-xml/pom.xml b/java-io-xml/pom.xml
diff --git a/java-io-xml/src/test/java/nbbrd/io/xml/XmlTest.java b/java-io-xml/src/test/java/nbbrd/io/xml/XmlTest.java
diff --git a/pom.xml b/pom.xml

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`import lombok.NonNull;`
`4`	`4`	`import nbbrd.io.FileFormatter;`
	`5`	`+import nbbrd.io.WrappedIOException;`
`5`	`6`	`import nbbrd.io.function.IOSupplier;`
`6`	`7`
`7`	`8`	`import java.io.File;`
`@@ -11,6 +12,7 @@`
`11`	`12`	`import java.nio.channels.Channels;`
`12`	`13`	`import java.nio.channels.FileChannel;`
`13`	`14`	`import java.nio.channels.FileLock;`
	`15`	`+import java.nio.channels.OverlappingFileLockException;`
`14`	`16`	`import java.nio.file.Path;`
`15`	`17`	`import java.nio.file.StandardOpenOption;`
`16`	`18`
`@@ -26,6 +28,8 @@ public void formatFile(@NonNull T value, @NonNull File target) throws IOExceptio`
`26`	`28`	`try (FileOutputStream stream = new FileOutputStream(checkTarget(target))) {`
`27`	`29`	`try (FileLock ignore = stream.getChannel().lock()) {`
`28`	`30`	`delegate.formatStream(value, stream);`
	`31`	`+ } catch (OverlappingFileLockException ex) {`
	`32`	`+ throw WrappedIOException.wrap(ex);`
`29`	`33`	`}`
`30`	`34`	`}`
`31`	`35`	`}`
`@@ -35,6 +39,8 @@ public void formatPath(@NonNull T value, @NonNull Path target) throws IOExceptio`
`35`	`39`	`try (FileChannel channel = FileChannel.open(checkTarget(target), StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {`
`36`	`40`	`try (FileLock ignore = channel.lock()) {`
`37`	`41`	`delegate.formatStream(value, Channels.newOutputStream(channel));`
	`42`	`+ } catch (OverlappingFileLockException ex) {`
	`43`	`+ throw WrappedIOException.wrap(ex);`
`38`	`44`	`}`
`39`	`45`	`}`
`40`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`import lombok.NonNull;`
`4`	`4`	`import nbbrd.io.FileParser;`
	`5`	`+import nbbrd.io.WrappedIOException;`
`5`	`6`	`import nbbrd.io.function.IOSupplier;`
`6`	`7`
`7`	`8`	`import java.io.File;`
`@@ -11,6 +12,7 @@`
`11`	`12`	`import java.nio.channels.Channels;`
`12`	`13`	`import java.nio.channels.FileChannel;`
`13`	`14`	`import java.nio.channels.FileLock;`
	`15`	`+import java.nio.channels.OverlappingFileLockException;`
`14`	`16`	`import java.nio.file.Path;`
`15`	`17`	`import java.nio.file.StandardOpenOption;`
`16`	`18`
`@@ -26,6 +28,8 @@ public final class LockingFileParser<T> implements FileParser<T> {`
`26`	`28`	`try (FileInputStream stream = new FileInputStream(checkSource(source))) {`
`27`	`29`	`try (FileLock ignore = stream.getChannel().lock(0, Long.MAX_VALUE, true)) {`
`28`	`30`	`return delegate.parseStream(stream);`
	`31`	`+ } catch (OverlappingFileLockException ex) {`
	`32`	`+ throw WrappedIOException.wrap(ex);`
`29`	`33`	`}`
`30`	`34`	`}`
`31`	`35`	`}`
`@@ -35,6 +39,8 @@ public final class LockingFileParser<T> implements FileParser<T> {`
`35`	`39`	`try (FileChannel channel = FileChannel.open(checkSource(source), StandardOpenOption.READ)) {`
`36`	`40`	`try (FileLock ignore = channel.lock(0, Long.MAX_VALUE, true)) {`
`37`	`41`	`return delegate.parseStream(Channels.newInputStream(channel));`
	`42`	`+ } catch (OverlappingFileLockException ex) {`
	`43`	`+ throw WrappedIOException.wrap(ex);`
`38`	`44`	`}`
`39`	`45`	`}`
`40`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,5 +28,6 @@`
`28`	`28`	`exports nbbrd.io.text;`
`29`	`29`	`exports nbbrd.io.zip;`
`30`	`30`
	`31`	`+ exports internal.io to nbbrd.io.xml, nbbrd.io.xml.bind, nbbrd.io.picocsv;`
`31`	`32`	`exports internal.io.text to nbbrd.io.xml, nbbrd.io.xml.bind, nbbrd.io.picocsv;`
`32`	`33`	`}`