Keep track of a static collection of all PackWriter instances

Stored in a weak concurrent hash map, which we clean up while iterating.
Usually the weak reference behavior should not be necessary because
PackWriters should be released with release(), but we still want to
avoid leaks when dealing with broken client code.

Change-Id: I337abb952ac6524f7f920fedf04065edf84d01d2

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/storage/pack/PackWriter.java b/org.eclipse.jgit/src/org/eclipse/jgit/storage/pack/PackWriter.java
index aac288ec5e7b04b3d586c1214d8b688d75dadb1e..95fc7a9e5edbfc7374de7b7fb6b2d9c88958c300 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/storage/pack/PackWriter.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/storage/pack/PackWriter.java
@@ -49,6 +49,7 @@ import static org.eclipse.jgit.storage.pack.StoredObjectRepresentation.PACK_WHOL
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.lang.ref.WeakReference;
 import java.security.MessageDigest;
 import java.text.MessageFormat;
 import java.util.ArrayList;
@@ -62,7 +63,9 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
@@ -141,6 +144,50 @@ import org.eclipse.jgit.util.TemporaryBuffer;
 public class PackWriter {
        private static final int PACK_VERSION_GENERATED = 2;
 
+       private static final Map<WeakReference<PackWriter>, Boolean> instances =
+                       new ConcurrentHashMap<WeakReference<PackWriter>, Boolean>();
+
+       private static final Iterable<PackWriter> instancesIterable = new Iterable<PackWriter>() {
+               public Iterator<PackWriter> iterator() {
+                       return new Iterator<PackWriter>() {
+                               private final Iterator<WeakReference<PackWriter>> it =
+                                               instances.keySet().iterator();
+                               private PackWriter next;
+
+                               public boolean hasNext() {
+                                       if (next != null)
+                                               return true;
+                                       while (it.hasNext()) {
+                                               WeakReference<PackWriter> ref = it.next();
+                                               next = ref.get();
+                                               if (next != null)
+                                                       return true;
+                                               it.remove();
+                                       }
+                                       return false;
+                               }
+
+                               public PackWriter next() {
+                                       if (hasNext()) {
+                                               PackWriter result = next;
+                                               next = null;
+                                               return result;
+                                       }
+                                       throw new NoSuchElementException();
+                               }
+
+                               public void remove() {
+                                       throw new UnsupportedOperationException();
+                               }
+                       };
+               }
+       };
+
+       /** @return all allocated, non-released PackWriters instances. */
+       public static Iterable<PackWriter> getInstances() {
+               return instancesIterable;
+       }
+
        @SuppressWarnings("unchecked")
        private final BlockList<ObjectToPack> objectsLists[] = new BlockList[Constants.OBJ_TAG + 1];
        {
@@ -176,6 +223,8 @@ public class PackWriter {
 
        private final MutableState state;
 
+       private final WeakReference<PackWriter> selfRef;
+
        private Statistics.ObjectType typeStats;
 
        private List<ObjectToPack> sortedByName;
@@ -269,6 +318,8 @@ public class PackWriter {
                reuseValidate = true; // be paranoid by default
                stats = new Statistics();
                state = new MutableState();
+               selfRef = new WeakReference<PackWriter>(this);
+               instances.put(selfRef, Boolean.TRUE);
        }
 
        /**
@@ -901,6 +952,7 @@ public class PackWriter {
                        myDeflater.end();
                        myDeflater = null;
                }
+               instances.remove(selfRef);
        }
 
        private void searchForReuse(ProgressMonitor monitor) throws IOException {