1 files changed, 43 insertions, 33 deletions

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java
index ed8f450c53..b7bb0cbce3 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java
@@ -16,13 +16,16 @@ import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.text.MessageFormat;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 import org.eclipse.jgit.errors.CompoundException;
@@ -112,16 +115,16 @@ class WalkFetchConnection extends BaseFetchConnection {
 	private final DateRevQueue localCommitQueue;
 
 	/** Objects we need to copy from the remote repository. */
-	private LinkedList<ObjectId> workQueue;
+	private Deque<ObjectId> workQueue;
 
 	/** Databases we have not yet obtained the list of packs from. */
-	private final LinkedList<WalkRemoteObjectDatabase> noPacksYet;
+	private final Deque<WalkRemoteObjectDatabase> noPacksYet;
 
 	/** Databases we have not yet obtained the alternates from. */
-	private final LinkedList<WalkRemoteObjectDatabase> noAlternatesYet;
+	private final Deque<WalkRemoteObjectDatabase> noAlternatesYet;
 
 	/** Packs we have discovered, but have not yet fetched locally. */
-	private final LinkedList<RemotePack> unfetchedPacks;
+	private final Map<String, RemotePack> unfetchedPacks;
 
 	/**
 	 * Packs whose indexes we have looked at in {@link #unfetchedPacks}.
@@ -163,13 +166,13 @@ class WalkFetchConnection extends BaseFetchConnection {
 		remotes = new ArrayList<>();
 		remotes.add(w);
 
-		unfetchedPacks = new LinkedList<>();
+		unfetchedPacks = new LinkedHashMap<>();
 		packsConsidered = new HashSet<>();
 
-		noPacksYet = new LinkedList<>();
+		noPacksYet = new ArrayDeque<>();
 		noPacksYet.add(w);
 
-		noAlternatesYet = new LinkedList<>();
+		noAlternatesYet = new ArrayDeque<>();
 		noAlternatesYet.add(w);
 
 		fetchErrors = new HashMap<>();
@@ -183,16 +186,14 @@ class WalkFetchConnection extends BaseFetchConnection {
 		LOCALLY_SEEN = revWalk.newFlag("LOCALLY_SEEN"); //$NON-NLS-1$
 
 		localCommitQueue = new DateRevQueue();
-		workQueue = new LinkedList<>();
+		workQueue = new ArrayDeque<>();
 	}
 
-	/** {@inheritDoc} */
 	@Override
 	public boolean didFetchTestConnectivity() {
 		return true;
 	}
 
-	/** {@inheritDoc} */
 	@Override
 	protected void doFetch(final ProgressMonitor monitor,
 			final Collection<Ref> want, final Set<ObjectId> have)
@@ -214,24 +215,21 @@ class WalkFetchConnection extends BaseFetchConnection {
 		}
 	}
 
-	/** {@inheritDoc} */
 	@Override
 	public Collection<PackLock> getPackLocks() {
 		return packLocks;
 	}
 
-	/** {@inheritDoc} */
 	@Override
 	public void setPackLockMessage(String message) {
 		lockMessage = message;
 	}
 
-	/** {@inheritDoc} */
 	@Override
 	public void close() {
 		inserter.close();
 		reader.close();
-		for (RemotePack p : unfetchedPacks) {
+		for (RemotePack p : unfetchedPacks.values()) {
 			if (p.tmpIdx != null)
 				p.tmpIdx.delete();
 		}
@@ -426,8 +424,9 @@ class WalkFetchConnection extends BaseFetchConnection {
 				if (packNameList == null || packNameList.isEmpty())
 					continue;
 				for (String packName : packNameList) {
-					if (packsConsidered.add(packName))
-						unfetchedPacks.add(new RemotePack(wrr, packName));
+					if (packsConsidered.add(packName)) {
+						unfetchedPacks.put(packName, new RemotePack(wrr, packName));
+					}
 				}
 				if (downloadPackedObject(pm, id))
 					return;
@@ -470,15 +469,27 @@ class WalkFetchConnection extends BaseFetchConnection {
 		}
 	}
 
+	private boolean downloadPackedObject(ProgressMonitor monitor,
+			AnyObjectId id) throws TransportException {
+		Set<String> brokenPacks = new HashSet<>();
+		try {
+			return downloadPackedObject(monitor, id, brokenPacks);
+		} finally {
+			brokenPacks.forEach(unfetchedPacks::remove);
+		}
+	}
+
 	@SuppressWarnings("Finally")
 	private boolean downloadPackedObject(final ProgressMonitor monitor,
-			final AnyObjectId id) throws TransportException {
+			final AnyObjectId id, Set<String> brokenPacks) throws TransportException {
 		// Search for the object in a remote pack whose index we have,
 		// but whose pack we do not yet have.
 		//
-		final Iterator<RemotePack> packItr = unfetchedPacks.iterator();
-		while (packItr.hasNext() && !monitor.isCancelled()) {
-			final RemotePack pack = packItr.next();
+		for (Entry<String, RemotePack> entry : unfetchedPacks.entrySet()) {
+			if (monitor.isCancelled()) {
+				break;
+			}
+			final RemotePack pack = entry.getValue();
 			try {
 				pack.openIndex(monitor);
 			} catch (IOException err) {
@@ -488,7 +499,7 @@ class WalkFetchConnection extends BaseFetchConnection {
 				// another source, so don't consider it a failure.
 				//
 				recordError(id, err);
-				packItr.remove();
+				brokenPacks.add(entry.getKey());
 				continue;
 			}
 
@@ -530,15 +541,16 @@ class WalkFetchConnection extends BaseFetchConnection {
 				// are unusable and we shouldn't consult them again.
 				//
 				try {
-					if (pack.tmpIdx != null)
+					if (pack.tmpIdx != null) {
 						FileUtils.delete(pack.tmpIdx);
-				} catch (IOException e) {
+					}
+				} catch (Throwable e) {
 					if (e1 != null) {
 						e.addSuppressed(e1);
 					}
 					throw new TransportException(e.getMessage(), e);
 				}
-				packItr.remove();
+				brokenPacks.add(entry.getKey());
 			}
 
 			if (!alreadyHave(id)) {
@@ -553,11 +565,9 @@ class WalkFetchConnection extends BaseFetchConnection {
 
 			// Complete any other objects that we can.
 			//
-			final Iterator<ObjectId> pending = swapFetchQueue();
-			while (pending.hasNext()) {
-				final ObjectId p = pending.next();
+			final Deque<ObjectId> pending = swapFetchQueue();
+			for (ObjectId p : pending) {
 				if (pack.index.hasObject(p)) {
-					pending.remove();
 					process(p);
 				} else {
 					workQueue.add(p);
@@ -569,9 +579,9 @@ class WalkFetchConnection extends BaseFetchConnection {
 		return false;
 	}
 
-	private Iterator<ObjectId> swapFetchQueue() {
-		final Iterator<ObjectId> r = workQueue.iterator();
-		workQueue = new LinkedList<>();
+	private Deque<ObjectId> swapFetchQueue() {
+		final Deque<ObjectId> r = workQueue;
+		workQueue = new ArrayDeque<>();
 		return r;
 	}