reftable: move AutoCloseable to ReftableReader

MergedReftable is not used as an AutoCloseable, because closing tables
is currently handled by DfsReftableStack#close.

Encode that a MergedReftable is a list of ReftableReaders. The previous
code suggested that we could form nested trees of MergedReftables,
which is not how we use reftables.

Change-Id: Icbe2fee8a5a12373f45fc5f97d8b1a2b14231c96
Signed-off-by: Han-Wen Nienhuys <hanwen@google.com>

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftable/MergedReftableTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftable/MergedReftableTest.java
index dd42aa0b381018aa9f3941d7c8923766708347b0..c20db7b96b1e155d5b50d71340eb65a657311cb5 100644 (file)
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftable/MergedReftableTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftable/MergedReftableTest.java
@@ -414,7 +414,7 @@ public class MergedReftableTest {
        }
 
        private static MergedReftable merge(byte[]... table) {
-               List<Reftable> stack = new ArrayList<>(table.length);
+               List<ReftableReader> stack = new ArrayList<>(table.length);
                for (byte[] b : table) {
                        stack.add(read(b));
                }

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsReftableStack.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsReftableStack.java
index b6b540388acdbeda2973591b0af8acf93c11cd98..59621a4e67de32649a4aa50dde7b53ddcf347cee 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsReftableStack.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsReftableStack.java
@@ -48,11 +48,11 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import org.eclipse.jgit.internal.storage.reftable.Reftable;
+import org.eclipse.jgit.internal.storage.reftable.ReftableReader;
 
 /**
  * Tracks multiple open
- * {@link org.eclipse.jgit.internal.storage.reftable.Reftable} instances.
+ * {@link org.eclipse.jgit.internal.storage.reftable.ReftableReader} instances.
  */
 public class DfsReftableStack implements AutoCloseable {
        /**
@@ -86,7 +86,7 @@ public class DfsReftableStack implements AutoCloseable {
        }
 
        private final List<DfsReftable> files;
-       private final List<Reftable> tables;
+       private final List<ReftableReader> tables;
 
        private DfsReftableStack(int tableCnt) {
                this.files = new ArrayList<>(tableCnt);
@@ -109,14 +109,14 @@ public class DfsReftableStack implements AutoCloseable {
         * @return unmodifiable list of tables, in the same order the files were
         *         passed to {@link #open(DfsReader, List)}.
         */
-       public List<Reftable> readers() {
+       public List<ReftableReader> readers() {
                return Collections.unmodifiableList(tables);
        }
 
        /** {@inheritDoc} */
        @Override
        public void close() {
-               for (Reftable t : tables) {
+               for (ReftableReader t : tables) {
                        try {
                                t.close();
                        } catch (IOException e) {

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/ReftableBatchRefUpdate.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/ReftableBatchRefUpdate.java
index 364052bf932d573003f466f537255aaa8e6a89bf..b19ffffba92f028779cc44f6f50d196755651e96 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/ReftableBatchRefUpdate.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/ReftableBatchRefUpdate.java
@@ -406,7 +406,7 @@ public class ReftableBatchRefUpdate extends BatchRefUpdate {
        private boolean canCompactTopOfStack(ReftableConfig cfg)
                        throws IOException {
                DfsReftableStack stack = refdb.stack();
-               List<Reftable> readers = stack.readers();
+               List<ReftableReader> readers = stack.readers();
                if (readers.isEmpty()) {
                        return false;
                }
@@ -427,10 +427,10 @@ public class ReftableBatchRefUpdate extends BatchRefUpdate {
 
        private ReftableWriter.Stats compactTopOfStack(OutputStream out,
                        ReftableConfig cfg, byte[] newTable) throws IOException {
-               List<Reftable> stack = refdb.stack().readers();
-               Reftable last = stack.get(stack.size() - 1);
+               List<ReftableReader> stack = refdb.stack().readers();
+               ReftableReader last = stack.get(stack.size() - 1);
 
-               List<Reftable> tables = new ArrayList<>(2);
+               List<ReftableReader> tables = new ArrayList<>(2);
                tables.add(last);
                tables.add(new ReftableReader(BlockSource.from(newTable)));
 

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/MergedReftable.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/MergedReftable.java
index f5d612f3e1b7c94fd953ddcacd22f2243ff6af1a..a4394066eac50f704ab5d4a6d22cbfa78e9b1c0b 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/MergedReftable.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/MergedReftable.java
@@ -67,13 +67,11 @@ import org.eclipse.jgit.lib.ReflogEntry;
  * A {@code MergedReftable} is not thread-safe.
  */
 public class MergedReftable extends Reftable {
-       private final Reftable[] tables;
+       private final ReftableReader[] tables;
 
        /**
         * Initialize a merged table reader.
         * <p>
-        * The tables in {@code tableStack} will be closed when this
-        * {@code MergedReftable} is closed.
         *
         * @param tableStack
         *            stack of tables to read from. The base of the stack is at
@@ -81,12 +79,12 @@ public class MergedReftable extends Reftable {
         *            {@code tableStack.size() - 1}. The top of the stack (higher
         *            index) shadows the base of the stack (lower index).
         */
-       public MergedReftable(List<Reftable> tableStack) {
-               tables = tableStack.toArray(new Reftable[0]);
+       public MergedReftable(List<ReftableReader> tableStack) {
+               tables = tableStack.toArray(new ReftableReader[0]);
 
                // Tables must expose deletes to this instance to correctly
                // shadow references from lower tables.
-               for (Reftable t : tables) {
+               for (ReftableReader t : tables) {
                        t.setIncludeDeletes(true);
                }
        }
@@ -161,14 +159,6 @@ public class MergedReftable extends Reftable {
                return m;
        }
 
-       /** {@inheritDoc} */
-       @Override
-       public void close() throws IOException {
-               for (Reftable t : tables) {
-                       t.close();
-               }
-       }
-
        int queueSize() {
                return Math.max(1, tables.length);
        }

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/Reftable.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/Reftable.java
index 860d044262a7371c8d982d4fc312939a6c969eb0..8f642617662009e079fd5fe26cb03bee18c4c2b5 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/Reftable.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/Reftable.java
@@ -58,7 +58,7 @@ import org.eclipse.jgit.lib.SymbolicRef;
 /**
  * Abstract table of references.
  */
-public abstract class Reftable implements AutoCloseable {
+public abstract class Reftable {
        /**
         * References to convert into a reftable
         *
@@ -295,8 +295,4 @@ public abstract class Reftable implements AutoCloseable {
                }
                return new SymbolicRef(ref.getName(), dst, ref.getUpdateIndex());
        }
-
-       /** {@inheritDoc} */
-       @Override
-       public abstract void close() throws IOException;
 }

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableCompactor.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableCompactor.java
index 2effda4bcb9e17f9290df7395996b5cb70940288..c73c245be523f8fd0e5310d3988c7c77fa3f4691 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableCompactor.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableCompactor.java
@@ -69,7 +69,7 @@ import org.eclipse.jgit.lib.ReflogEntry;
  */
 public class ReftableCompactor {
        private final ReftableWriter writer;
-       private final ArrayDeque<Reftable> tables = new ArrayDeque<>();
+       private final ArrayDeque<ReftableReader> tables = new ArrayDeque<>();
 
        private long compactBytesLimit;
        private long bytesToCompact;
@@ -188,12 +188,10 @@ public class ReftableCompactor {
         * @throws java.io.IOException
         *             update indexes of a reader cannot be accessed.
         */
-       public void addAll(List<? extends Reftable> readers) throws IOException {
-               tables.addAll(readers);
-               for (Reftable r : readers) {
-                       if (r instanceof ReftableReader) {
-                               adjustUpdateIndexes((ReftableReader) r);
-                       }
+       public void addAll(List<ReftableReader> readers) throws IOException {
+               for (ReftableReader r : readers) {
+                       tables.add(r);
+                       adjustUpdateIndexes(r);
                }
        }
 

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableReader.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableReader.java
index 75e98958f450632be18cc5cad0a7ebbdfc61886f..c5e667449af9c4b52b09e0a443342354e3aced3d 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableReader.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftable/ReftableReader.java
@@ -78,7 +78,7 @@ import org.eclipse.jgit.util.NB;
  * {@code ReftableReader} is not thread-safe. Concurrent readers need their own
  * instance to read from the same file.
  */
-public class ReftableReader extends Reftable {
+public class ReftableReader extends Reftable implements AutoCloseable {
        private final BlockSource src;
 
        private int blockSize = -1;