OAK-11571: commons: add Closer class (similar to Guava Closer) - rethrow() just silences the close() method

Author: reschke

oak-commons/src/main/java/org/apache/jackrabbit/oak/commons/pio/Closer.java

@@ -42,8 +42,7 @@ private Closer() {
     private final Deque<Closeable> closeables = new ArrayDeque<>();
 
     // set by rethrow method
-    private Throwable rethrow = null;
-
+    private boolean suppressExceptionsOnClose = false;
     /**
      * Create instance of Closer.
      */
@@ -90,33 +89,23 @@ public void close() throws IOException {
             }
         }
 
-        // consider exceptions passed to rethrow()
-        if (rethrow instanceof IOException) {
-            throw (IOException) rethrow;
-        } else if (rethrow instanceof RuntimeException) {
-            throw (RuntimeException) rethrow;
-        } else if (rethrow != null) {
-            throw new RuntimeException(rethrow);
-        }
-
-        // otherwise throw the IOException we selected
-        if (toThrow != null) {
+        // potential IOException is suppressed when retrow was called
+        if (!suppressExceptionsOnClose && toThrow != null) {
             throw toThrow;
         }
     }
 
     /**
-     * Stores a {@link Throwable} for later use in {@link #close()} and
-     * rethrows it (potentially wrapped into {@link RuntimeException} or
-     * {@link Error}).
+     * Sets a flag indicating that this method was called, then rethrows the
+     * given exception.
      * <p>
-     * {@link #close()} will use the exception passed in the last call of this
-     * method.
+     * {@link #close()} will not throw when this method was called before.
      * @return never returns
      * @throws IOException wrapping the input, when needed
      */
     public RuntimeException rethrow(@NotNull Throwable throwable) throws IOException {
-        rethrow = Objects.requireNonNull(throwable);
+        Objects.requireNonNull(throwable);
+        suppressExceptionsOnClose = true;
         if (throwable instanceof IOException) {
             throw (IOException) throwable;
         } else if (throwable instanceof RuntimeException) {

oak-commons/src/test/java/org/apache/jackrabbit/oak/commons/pio/CloserTest.java

@@ -27,6 +27,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -151,4 +152,32 @@ public void testRethrowChecked() throws IOException {
                     ex.getCause() instanceof InterruptedException);
         }
     }
+
+    @Test
+    public void compareClosers() {
+        // when rethrow was called, IOExceptions that happened upon close will be swallowed
+
+        com.google.common.io.Closer guavaCloser = com.google.common.io.Closer.create();
+        Closer oakCloser = Closer.create();
+
+        try {
+            throw oakCloser.rethrow(new InterruptedException());
+        } catch (Exception e) {}
+
+        try {
+            throw guavaCloser.rethrow(new InterruptedException());
+        } catch (Exception e) {}
+
+        try {
+            oakCloser.close();
+        } catch (Exception e) {
+            fail("should not throw but got: " + e);
+        }
+
+        try {
+            guavaCloser.close();
+        } catch (Exception e) {
+            fail("should not throw but got: " + e);
+        }
+    }
 }