JGit cache bug

@@ -0,0 +1,125 @@
+package org.spearce.jgit.lib;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.spearce.jgit.errors.IncorrectObjectTypeException;
+import org.spearce.jgit.errors.MissingObjectException;
+import org.spearce.jgit.revwalk.RevObject;
+import org.spearce.jgit.revwalk.RevWalk;
+
+public class WindowCacheTest extends RepositoryTestCase {
+
+	public void setUp() throws Exception {
+		WindowCacheConfig windowCacheConfig = new WindowCacheConfig();
+		windowCacheConfig.setPackedGitOpenFiles(1);
+		WindowCache.reconfigure(windowCacheConfig);
+		super.setUp();
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		WindowCacheConfig windowCacheConfig = new WindowCacheConfig();
+		WindowCache.reconfigure(windowCacheConfig);
+	}
+
+	/*
+	 * Add pack, find objects in new pack Replace packs, find objects in another
+	 * pack than original, don't choke on lost pack
+	 */
+	public void testObjectInNewPack() throws IncorrectObjectTypeException,
+			IOException {
+		Repository extra = createNewEmptyRepo();
+		RevObject o1 = writeBlob(extra, db,
+				"nihuioijoisuoiudyosyudoiuyusyuoiyewData");
+		PackWriter packWriter = new PackWriter(extra, new TextProgressMonitor());
+		packWriter.addObject(o1);
+		ObjectId name = packWriter.computeName();
+		File packFileName = fullPackFileName(db, name, ".pack");
+		FileOutputStream pos = new FileOutputStream(packFileName);
+		packWriter.writePack(pos);
+		pos.close();
+		File idxfname = fullPackFileName(db, name, ".idx");
+		FileOutputStream ios = new FileOutputStream(idxfname);
+		packWriter.writeIndex(ios);
+		ios.close();
+		assertEquals(o1.name(), new RevWalk(db).parseAny(o1).name());
+	}
+
+	/*
+	 * Add pack, find objects in new pack Replace packs, find objects in another
+	 * pack than original, don't choke on lost pack
+	 */
+	public void testObjectMovedToNewPack() throws IncorrectObjectTypeException,
+			IOException {
+		Repository extra = createNewEmptyRepo();
+		RevObject o1 = writeBlob(extra, db,
+				"nihuioijoisuoiudyosyudoiuyusyuoiyewData1");
+		PackWriter packWriter1 = new PackWriter(extra,
+				new TextProgressMonitor());
+		packWriter1.addObject(o1);
+		ObjectId name1 = packWriter1.computeName();
+		File packFileName1 = fullPackFileName(db, name1, ".pack");
+		FileOutputStream pos1 = new FileOutputStream(packFileName1);
+		packWriter1.writePack(pos1);
+		pos1.close();
+		File idxfname1 = fullPackFileName(db, name1, ".idx");
+		FileOutputStream ios1 = new FileOutputStream(idxfname1);
+		packWriter1.writeIndex(ios1);
+		ios1.close();
+		assertEquals(o1.name(), new RevWalk(db).parseAny(o1).name());
+
+		// Ok, lets repack this repo
+		// create an additional object
+		RevObject o2 = writeBlob(extra, db,
+				"nihuioijoisuoiudyosyudoiuyusyuoiyewData2");
+		PackWriter packWriter2 = new PackWriter(extra,
+				new TextProgressMonitor());
+		packWriter2.addObject(o1);
+		packWriter2.addObject(o2);
+		ObjectId name2 = packWriter2.computeName();
+		File packFileName2 = fullPackFileName(db, name2, ".pack");
+		FileOutputStream pos2 = new FileOutputStream(packFileName2);
+		packWriter2.writePack(pos2);
+		pos2.close();
+		File idxfname2 = fullPackFileName(db, name2, ".idx");
+		FileOutputStream ios2 = new FileOutputStream(idxfname2);
+		packWriter2.writeIndex(ios2);
+		ios2.close();
+		assertEquals(o2.name(), new RevWalk(db).parseAny(o2).name());
+
+		WindowCacheConfig windowCacheConfig = new WindowCacheConfig();
+		windowCacheConfig.setPackedGitOpenFiles(1);
+		WindowCache.reconfigure(windowCacheConfig);
+		packFileName1.delete();
+		idxfname1.delete();
+
+		// Now here is the interesting thing. Will git figure the new
+		// object exists in the new pack, and not the old one.
+		assertEquals(o1.name(), new RevWalk(db).parseAny(o1).name());
+	}
+
+	private File fullPackFileName(Repository repository, ObjectId hash,
+			String suffix) {
+		return new File(new File(repository.getObjectsDirectory(), "pack"),
+				"pack-" + hash.name() + suffix);
+	}
+
+	private RevObject writeBlob(final Repository repo, final Repository notIn,
+			final String data) throws IOException {
+		RevWalk revWalk = new RevWalk(repo);
+		byte[] bytes = data.getBytes(Constants.CHARACTER_ENCODING);
+		ObjectId id = new ObjectWriter(repo).writeBlob(bytes.length,
+				new ByteArrayInputStream(bytes));
+		try {
+			assertNull(
+					"Oops, We want new objects that we do not have yet, for this test!",
+					new RevWalk(notIn).parseAny(id));
+		} catch (MissingObjectException e) {
+			// Ok
+		}
+		return revWalk.lookupBlob(id);
+	}
+}

@@ -98,6 +98,13 @@ public void testObjectMovedToNewPack() throws IncorrectObjectTypeException,
 
 		// Now here is the interesting thing. Will git figure the new
 		// object exists in the new pack, and not the old one.
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.gc();
 		assertEquals(o1.name(), new RevWalk(db).parseAny(o1).name());
 	}
 

@@ -280,6 +280,13 @@ public void close() {
 	}
 
 	void cacheOpen() throws IOException {
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.gc();
 		fd = new RandomAccessFile(fPath, "r");
 		length = fd.length();
 		try {

@@ -100,6 +100,8 @@
 	private GitIndex index;
 
 	private List<RepositoryListener> listeners = new Vector<RepositoryListener>(); // thread safe
+
+	private int packFileListGeneration;
 	static private List<RepositoryListener> allListeners = new Vector<RepositoryListener>(); // thread safe
 
 	/**

@@ -291,6 +293,40 @@ public ObjectLoader openObject(final AnyObjectId id)
 	 */
 	public ObjectLoader openObject(final WindowCursor curs, final AnyObjectId id)
 			throws IOException {
+		boolean scanned = false;
+		try {
+			ObjectLoader loader = openObjectInPacks(curs, id);
+			if (loader != null)
+				return loader;
+		} catch (FileNotFoundException fnfe) {
+			System.out.println(new java.util.Date().toString() + ": failed to load " + id + ", rescanning for new packs");
+			scanned = true;
+			if (scanForPacks()) {
+				ObjectLoader loader = openObjectInPacks(curs, id);
+				if (loader != null)
+					return loader;
+			}
+		}
+		try {
+			return new UnpackedObjectLoader(this, id);
+		} catch (FileNotFoundException fnfe) {
+			System.out.println(new java.util.Date().toString() + ": failed to load " + id + ", rescanning for new packs");
+			if (!scanned && scanForPacks()) {
+				ObjectLoader loader = openObjectInPacks(curs, id);
+				if (loader != null)
+					return loader;
+				try {
+					return new UnpackedObjectLoader(this, id);
+				} catch (FileNotFoundException fnfe2) {
+					return null;
+				}
+			}
+			return null;
+		}
+	}
+
+	private ObjectLoader openObjectInPacks(final WindowCursor curs, final AnyObjectId id)
+			throws IOException {
 		final PackFile[] packs = packs();
 		int k = packs.length;
 		while (k > 0) {

@@ -298,11 +334,7 @@ public ObjectLoader openObject(final WindowCursor curs, final AnyObjectId id)
 			if (ol != null)
 				return ol;
 		}
-		try {
-			return new UnpackedObjectLoader(this, id);
-		} catch (FileNotFoundException fnfe) {
-			return null;
-		}
+		return null;
 	}
 
 	/**

@@ -813,23 +845,39 @@ synchronized (this) {
 	}
 
 	/**
-	 * Scan the object dirs, including alternates for packs
-	 * to use.
+	 * Scan the object dirs, including alternates for packs to use.
+	 * 
+	 * @return true if new packs were found
 	 */
-	public void scanForPacks() {
+	public boolean scanForPacks() {
+		int oldPackFileListGeneration = packFileListGeneration;
 		final ArrayList<PackFile> p = new ArrayList<PackFile>();
-		p.addAll(Arrays.asList(packs()));
 		for (final File d : objectsDirs())
-			scanForPacks(new File(d, "pack"), p);
+			scanForPacks(new File(d, "pack"), p, packFileList);
 		final PackFile[] arr = new PackFile[p.size()];
 		p.toArray(arr);
 		Arrays.sort(arr, PackFile.SORT);
 		synchronized (this) {
+			if (!samePackfileArray(packFileList, arr))
+				packFileListGeneration++;
 			packFileList = arr;
 		}
+		return oldPackFileListGeneration != packFileListGeneration;
 	}
 
-	private void scanForPacks(final File packDir, Collection<PackFile> packList) {
+	private static<T> boolean samePackfileArray(PackFile[] oldList, PackFile[] newList) {
+		if (oldList == null)
+			return false;
+		if (oldList.length != newList.length)
+			return false;
+		for (int i = 0; i < oldList.length; ++i) {
+			if (!oldList[i].getPackFile().equals(newList[i].getPackFile()))
+				return false;
+		}
+		return true;
+	}
+	
+	private void scanForPacks(final File packDir, Collection<PackFile> packList, PackFile[] oldPackFileList) {
 		final String[] idxList = packDir.list(new FilenameFilter() {
 			public boolean accept(final File baseDir, final String n) {
 				// Must match "pack-[0-9a-f]{40}.idx" to be an index.

@@ -851,9 +899,11 @@ public boolean accept(final File baseDir, final String n) {
 					continue;
 				}
 
-				for (final PackFile p : packList) {
-					if (packFile.equals(p.getPackFile()))
+				for (final PackFile p : oldPackFileList) {
+					if (packFile.equals(p.getPackFile())) {
+						packList.add(p);
 						continue SCAN;
+					}
 				}
 
 				packList.add(new PackFile(idxFile, packFile));