Deprecate Repository#getReflogReader methods

instead use Repository.getRefDatabase().getReflogReader().

Change-Id: I5e66a512c12e11d0ec3275fffde4adb8483430f2

22 files changed, 288 insertions, 191 deletions

diff --git a/org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java b/org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java
index 850e895790..b0d17adb3a 100644
--- a/org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java
+++ b/org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java
@@ -1728,7 +1728,8 @@ public class SmartClientSmartServerTest extends AllProtocolsHttpTestCase {
 		assertEquals(Q, remoteRepository.exactRef(dstName).getObjectId());
 		fsck(remoteRepository, Q);
 
-		final ReflogReader log = remoteRepository.getReflogReader(dstName);
+		final ReflogReader log = remoteRepository.getRefDatabase()
+				.getReflogReader(dstName);
 		assertNotNull("has log for " + dstName, log);
 
 		final ReflogEntry last = log.getLastEntry();
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CherryPickCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CherryPickCommandTest.java
index be3b33a9c5..a9bd126ff3 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CherryPickCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CherryPickCommandTest.java
@@ -34,6 +34,7 @@ import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.ReflogReader;
 import org.eclipse.jgit.lib.RepositoryState;
 import org.eclipse.jgit.merge.ContentMergeStrategy;
@@ -529,10 +530,11 @@ public class CherryPickCommandTest extends RepositoryTestCase {
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 
 		if (reason == null) {
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("cherry-pick: "));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("cherry-pick: "));
 		}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java
index db5b27c2ab..f70ada4e30 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CloneCommandTest.java
@@ -182,7 +182,8 @@ public class CloneCommandTest extends RepositoryTestCase {
 
 	private static boolean hasRefLog(Repository repo, Ref ref) {
 		try {
-			return repo.getReflogReader(ref.getName()).getLastEntry() != null;
+			return repo.getRefDatabase().getReflogReader(ref.getName())
+					.getLastEntry() != null;
 		} catch (IOException ioe) {
 			throw new IllegalStateException(ioe);
 		}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitAndLogCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitAndLogCommandTest.java
index 57e5d4958f..ced24b5928 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitAndLogCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitAndLogCommandTest.java
@@ -26,6 +26,7 @@ import org.eclipse.jgit.junit.RepositoryTestCase;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.RefUpdate;
 import org.eclipse.jgit.lib.ReflogReader;
 import org.eclipse.jgit.revwalk.RevCommit;
@@ -69,10 +70,11 @@ public class CommitAndLogCommandTest extends RepositoryTestCase {
 				l--;
 			}
 			assertEquals(l, -1);
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(
 					reader.getLastEntry().getComment().startsWith("commit:"));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(
 					reader.getLastEntry().getComment().startsWith("commit:"));
 		}
@@ -248,10 +250,11 @@ public class CommitAndLogCommandTest extends RepositoryTestCase {
 				c++;
 			}
 			assertEquals(1, c);
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("commit (amend):"));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("commit (amend):"));
 		}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
index 2cbd223ee8..d40df26690 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/CommitCommandTest.java
@@ -435,10 +435,12 @@ public class CommitCommandTest extends RepositoryTestCase {
 
 			assertEquals(1, squashedCommit.getParentCount());
 			assertNull(db.readSquashCommitMsg());
-			assertEquals("commit: Squashed commit of the following:", db
-					.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-			assertEquals("commit: Squashed commit of the following:", db
-					.getReflogReader(db.getBranch()).getLastEntry().getComment());
+			assertEquals("commit: Squashed commit of the following:",
+					db.getRefDatabase().getReflogReader(Constants.HEAD)
+							.getLastEntry().getComment());
+			assertEquals("commit: Squashed commit of the following:",
+					db.getRefDatabase().getReflogReader(db.getBranch())
+							.getLastEntry().getComment());
 		}
 	}
 
@@ -455,12 +457,15 @@ public class CommitCommandTest extends RepositoryTestCase {
 			git.commit().setMessage("c3").setAll(true)
 					.setReflogComment("testRl").call();
 
-			db.getReflogReader(Constants.HEAD).getReverseEntries();
+			db.getRefDatabase().getReflogReader(Constants.HEAD)
+					.getReverseEntries();
 
 			assertEquals("testRl;commit (initial): c1;", reflogComments(
-					db.getReflogReader(Constants.HEAD).getReverseEntries()));
+					db.getRefDatabase().getReflogReader(Constants.HEAD)
+							.getReverseEntries()));
 			assertEquals("testRl;commit (initial): c1;", reflogComments(
-					db.getReflogReader(db.getBranch()).getReverseEntries()));
+					db.getRefDatabase().getReflogReader(db.getBranch())
+							.getReverseEntries()));
 		}
 	}
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/FetchCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/FetchCommandTest.java
index 3ec454cfc3..3731347f11 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/FetchCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/FetchCommandTest.java
@@ -92,8 +92,8 @@ public class FetchCommandTest extends RepositoryTestCase {
 
 		assertTrue(remoteRef.getName().startsWith(Constants.R_REMOTES));
 		assertEquals(defaultBranchSha1, remoteRef.getObjectId());
-		assertNotNull(git.getRepository().getReflogReader(remoteRef.getName())
-				.getLastEntry());
+		assertNotNull(git.getRepository().getRefDatabase()
+				.getReflogReader(remoteRef.getName()).getLastEntry());
 	}
 
 	@Test
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java
index 917b6c3297..ba13f8ac1f 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/MergeCommandTest.java
@@ -33,6 +33,7 @@ import org.eclipse.jgit.junit.TestRepository;
 import org.eclipse.jgit.junit.TestRepository.BranchBuilder;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryState;
 import org.eclipse.jgit.lib.Sets;
@@ -76,11 +77,10 @@ public class MergeCommandTest extends RepositoryTestCase {
 			assertEquals(MergeResult.MergeStatus.ALREADY_UP_TO_DATE, result.getMergeStatus());
 		}
 		// no reflog entry written by merge
-		assertEquals("commit (initial): initial commit",
-				db
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("commit (initial): initial commit", refDb
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-		assertEquals("commit (initial): initial commit",
-				db
+		assertEquals("commit (initial): initial commit", refDb
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
@@ -96,9 +96,9 @@ public class MergeCommandTest extends RepositoryTestCase {
 			assertEquals(second, result.getNewHead());
 		}
 		// no reflog entry written by merge
-		assertEquals("commit: second commit", db
+		assertEquals("commit: second commit", db.getRefDatabase()
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-		assertEquals("commit: second commit", db
+		assertEquals("commit: second commit", db.getRefDatabase()
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
@@ -117,10 +117,13 @@ public class MergeCommandTest extends RepositoryTestCase {
 			assertEquals(MergeResult.MergeStatus.FAST_FORWARD, result.getMergeStatus());
 			assertEquals(second, result.getNewHead());
 		}
+		RefDatabase refDb = db.getRefDatabase();
 		assertEquals("merge refs/heads/master: Fast-forward",
-				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
+				refDb.getReflogReader(Constants.HEAD)
+						.getLastEntry().getComment());
 		assertEquals("merge refs/heads/master: Fast-forward",
-				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
+				refDb.getReflogReader(db.getBranch())
+						.getLastEntry().getComment());
 	}
 
 	@Test
@@ -140,9 +143,10 @@ public class MergeCommandTest extends RepositoryTestCase {
 					result.getMergeStatus());
 			assertEquals(second, result.getNewHead());
 		}
-		assertEquals("merge refs/heads/master: Fast-forward", db
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("merge refs/heads/master: Fast-forward", refDb
 				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-		assertEquals("merge refs/heads/master: Fast-forward", db
+		assertEquals("merge refs/heads/master: Fast-forward", refDb
 				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
@@ -171,10 +175,11 @@ public class MergeCommandTest extends RepositoryTestCase {
 			assertEquals(MergeResult.MergeStatus.FAST_FORWARD, result.getMergeStatus());
 			assertEquals(second, result.getNewHead());
 		}
-		assertEquals("merge refs/heads/master: Fast-forward",
-				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
-		assertEquals("merge refs/heads/master: Fast-forward",
-				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("merge refs/heads/master: Fast-forward", refDb
+				.getReflogReader(Constants.HEAD).getLastEntry().getComment());
+		assertEquals("merge refs/heads/master: Fast-forward", refDb
+				.getReflogReader(db.getBranch()).getLastEntry().getComment());
 	}
 
 	@Test
@@ -229,14 +234,17 @@ public class MergeCommandTest extends RepositoryTestCase {
 					.include(db.exactRef(R_HEADS + MASTER)).call();
 			assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 		}
+		RefDatabase refDb = db.getRefDatabase();
 		assertEquals(
 				"merge refs/heads/master: Merge made by "
 						+ mergeStrategy.getName() + ".",
-				db.getReflogReader(Constants.HEAD).getLastEntry().getComment());
+				refDb.getReflogReader(Constants.HEAD).getLastEntry()
+						.getComment());
 		assertEquals(
 				"merge refs/heads/master: Merge made by "
 						+ mergeStrategy.getName() + ".",
-				db.getReflogReader(db.getBranch()).getLastEntry().getComment());
+				refDb.getReflogReader(db.getBranch()).getLastEntry()
+						.getComment());
 	}
 
 	@Theory
@@ -662,14 +670,17 @@ public class MergeCommandTest extends RepositoryTestCase {
 					.setStrategy(MergeStrategy.RESOLVE).call();
 			assertEquals(MergeStatus.MERGED, result.getMergeStatus());
 			assertEquals("1\nb(1)\n3\n", read(new File(db.getWorkTree(), "b")));
-			assertEquals("merge " + secondCommit.getId().getName()
-					+ ": Merge made by resolve.", db
-					.getReflogReader(Constants.HEAD)
-					.getLastEntry().getComment());
-			assertEquals("merge " + secondCommit.getId().getName()
-					+ ": Merge made by resolve.", db
-					.getReflogReader(db.getBranch())
-					.getLastEntry().getComment());
+			RefDatabase refDb = db.getRefDatabase();
+			assertEquals(
+					"merge " + secondCommit.getId().getName()
+							+ ": Merge made by resolve.",
+					refDb.getReflogReader(Constants.HEAD).getLastEntry()
+							.getComment());
+			assertEquals(
+					"merge " + secondCommit.getId().getName()
+							+ ": Merge made by resolve.",
+					refDb.getReflogReader(db.getBranch()).getLastEntry()
+							.getComment());
 		}
 	}
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
index 84aa4b58a8..4c8cf06a67 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RebaseCommandTest.java
@@ -57,6 +57,7 @@ import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.PersonIdent;
 import org.eclipse.jgit.lib.RebaseTodoLine;
 import org.eclipse.jgit.lib.RebaseTodoLine.Action;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.RefUpdate;
 import org.eclipse.jgit.lib.ReflogEntry;
 import org.eclipse.jgit.lib.RepositoryState;
@@ -133,11 +134,12 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		checkFile(file2, "file2");
 		assertEquals(Status.FAST_FORWARD, res.getStatus());
 
-		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> headLog = refDb.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
-		List<ReflogEntry> topicLog = db.getReflogReader("refs/heads/topic")
+		List<ReflogEntry> topicLog = refDb.getReflogReader("refs/heads/topic")
 				.getReverseEntries();
-		List<ReflogEntry> masterLog = db.getReflogReader("refs/heads/master")
+		List<ReflogEntry> masterLog = refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries();
 		assertEquals("rebase finished: returning to refs/heads/topic", headLog
 				.get(0).getComment());
@@ -179,11 +181,12 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		checkFile(file2, "file2 new content");
 		assertEquals(Status.FAST_FORWARD, res.getStatus());
 
-		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> headLog = refDb.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
-		List<ReflogEntry> topicLog = db.getReflogReader("refs/heads/topic")
+		List<ReflogEntry> topicLog = refDb.getReflogReader("refs/heads/topic")
 				.getReverseEntries();
-		List<ReflogEntry> masterLog = db.getReflogReader("refs/heads/master")
+		List<ReflogEntry> masterLog = refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries();
 		assertEquals("rebase finished: returning to refs/heads/topic", headLog
 				.get(0).getComment());
@@ -447,13 +450,14 @@ public class RebaseCommandTest extends RepositoryTestCase {
 			assertEquals(a, rw.next());
 		}
 
-		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> headLog = refDb.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
-		List<ReflogEntry> sideLog = db.getReflogReader("refs/heads/side")
+		List<ReflogEntry> sideLog = refDb.getReflogReader("refs/heads/side")
 				.getReverseEntries();
-		List<ReflogEntry> topicLog = db.getReflogReader("refs/heads/topic")
+		List<ReflogEntry> topicLog = refDb.getReflogReader("refs/heads/topic")
 				.getReverseEntries();
-		List<ReflogEntry> masterLog = db.getReflogReader("refs/heads/master")
+		List<ReflogEntry> masterLog = refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries();
 		assertEquals("rebase finished: returning to refs/heads/topic", headLog
 				.get(0).getComment());
@@ -768,9 +772,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		RebaseResult result = git.rebase().setUpstream(parent).call();
 		assertEquals(Status.UP_TO_DATE, result.getStatus());
 
-		assertEquals(2, db.getReflogReader(Constants.HEAD).getReverseEntries()
-				.size());
-		assertEquals(2, db.getReflogReader("refs/heads/master")
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(2, refDb.getReflogReader(Constants.HEAD)
+				.getReverseEntries().size());
+		assertEquals(2, refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries().size());
 	}
 
@@ -786,9 +791,10 @@ public class RebaseCommandTest extends RepositoryTestCase {
 		RebaseResult res = git.rebase().setUpstream(first).call();
 		assertEquals(Status.UP_TO_DATE, res.getStatus());
 
-		assertEquals(1, db.getReflogReader(Constants.HEAD).getReverseEntries()
-				.size());
-		assertEquals(1, db.getReflogReader("refs/heads/master")
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(1, refDb.getReflogReader(Constants.HEAD)
+				.getReverseEntries().size());
+		assertEquals(1, refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries().size());
 	}
 
@@ -846,11 +852,12 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					db.resolve(Constants.HEAD)).getParent(0));
 		}
 		assertEquals(origHead, db.readOrigHead());
-		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> headLog = refDb.getReflogReader(Constants.HEAD)
 				.getReverseEntries();
-		List<ReflogEntry> topicLog = db.getReflogReader("refs/heads/topic")
+		List<ReflogEntry> topicLog = refDb.getReflogReader("refs/heads/topic")
 				.getReverseEntries();
-		List<ReflogEntry> masterLog = db.getReflogReader("refs/heads/master")
+		List<ReflogEntry> masterLog = refDb.getReflogReader("refs/heads/master")
 				.getReverseEntries();
 		assertEquals(2, masterLog.size());
 		assertEquals(3, topicLog.size());
@@ -898,8 +905,8 @@ public class RebaseCommandTest extends RepositoryTestCase {
 					db.resolve(Constants.HEAD)).getParent(0));
 		}
 
-		List<ReflogEntry> headLog = db.getReflogReader(Constants.HEAD)
-				.getReverseEntries();
+		List<ReflogEntry> headLog = db.getRefDatabase()
+				.getReflogReader(Constants.HEAD).getReverseEntries();
 		assertEquals(8, headLog.size());
 		assertEquals("rebase: change file1 in topic", headLog.get(0)
 				.getComment());
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/ResetCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/ResetCommandTest.java
index 8a479a0ca0..4265806078 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/ResetCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/ResetCommandTest.java
@@ -36,6 +36,7 @@ import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
 import org.eclipse.jgit.treewalk.TreeWalk;
@@ -557,43 +558,45 @@ public class ResetCommandTest extends RepositoryTestCase {
 	private void assertReflog(ObjectId prevHead, ObjectId head)
 			throws IOException {
 		// Check the reflog for HEAD
-		String actualHeadMessage = db.getReflogReader(Constants.HEAD)
+		RefDatabase refDb = db.getRefDatabase();
+		String actualHeadMessage = refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getComment();
 		String expectedHeadMessage = head.getName() + ": updating HEAD";
 		assertEquals(expectedHeadMessage, actualHeadMessage);
-		assertEquals(head.getName(), db.getReflogReader(Constants.HEAD)
+		assertEquals(head.getName(), refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getNewId().getName());
-		assertEquals(prevHead.getName(), db.getReflogReader(Constants.HEAD)
+		assertEquals(prevHead.getName(), refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getOldId().getName());
 
 		// The reflog for master contains the same as the one for HEAD
-		String actualMasterMessage = db.getReflogReader("refs/heads/master")
+		String actualMasterMessage = refDb.getReflogReader("refs/heads/master")
 				.getLastEntry().getComment();
 		String expectedMasterMessage = head.getName() + ": updating HEAD"; // yes!
 		assertEquals(expectedMasterMessage, actualMasterMessage);
-		assertEquals(head.getName(), db.getReflogReader(Constants.HEAD)
+		assertEquals(head.getName(), refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getNewId().getName());
-		assertEquals(prevHead.getName(), db
-				.getReflogReader("refs/heads/master").getLastEntry().getOldId()
-				.getName());
+		assertEquals(prevHead.getName(),
+				refDb.getReflogReader("refs/heads/master").getLastEntry()
+						.getOldId().getName());
 	}
 
 	private void assertReflogDisabled(ObjectId head)
 			throws IOException {
+		RefDatabase refDb = db.getRefDatabase();
 		// Check the reflog for HEAD
-		String actualHeadMessage = db.getReflogReader(Constants.HEAD)
+		String actualHeadMessage = refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getComment();
 		String expectedHeadMessage = "commit: adding a.txt and dir/b.txt";
 		assertEquals(expectedHeadMessage, actualHeadMessage);
-		assertEquals(head.getName(), db.getReflogReader(Constants.HEAD)
+		assertEquals(head.getName(), refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getOldId().getName());
 
 		// The reflog for master contains the same as the one for HEAD
-		String actualMasterMessage = db.getReflogReader("refs/heads/master")
+		String actualMasterMessage = refDb.getReflogReader("refs/heads/master")
 				.getLastEntry().getComment();
 		String expectedMasterMessage = "commit: adding a.txt and dir/b.txt";
 		assertEquals(expectedMasterMessage, actualMasterMessage);
-		assertEquals(head.getName(), db.getReflogReader(Constants.HEAD)
+		assertEquals(head.getName(), refDb.getReflogReader(Constants.HEAD)
 				.getLastEntry().getOldId().getName());
 	}
 	/**
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RevertCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RevertCommandTest.java
index afd6708d21..e4d0eb76f7 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RevertCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/RevertCommandTest.java
@@ -29,6 +29,7 @@ import org.eclipse.jgit.junit.RepositoryTestCase;
 import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.ReflogReader;
 import org.eclipse.jgit.lib.RepositoryState;
 import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
@@ -87,10 +88,11 @@ public class RevertCommandTest extends RepositoryTestCase {
 			assertEquals("create a", history.next().getFullMessage());
 			assertFalse(history.hasNext());
 
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
 		}
@@ -170,10 +172,11 @@ public class RevertCommandTest extends RepositoryTestCase {
 			assertEquals("add first", history.next().getFullMessage());
 			assertFalse(history.hasNext());
 
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
 		}
@@ -223,10 +226,11 @@ public class RevertCommandTest extends RepositoryTestCase {
 			assertEquals("add first", history.next().getFullMessage());
 			assertFalse(history.hasNext());
 
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
-			reader = db.getReflogReader(db.getBranch());
+			reader = refDb.getReflogReader(db.getBranch());
 			assertTrue(reader.getLastEntry().getComment()
 					.startsWith("revert: Revert \""));
 		}
@@ -431,12 +435,13 @@ public class RevertCommandTest extends RepositoryTestCase {
 		assertEquals(RepositoryState.SAFE, db.getRepositoryState());
 
 		if (reason == null) {
-			ReflogReader reader = db.getReflogReader(Constants.HEAD);
-			assertTrue(reader.getLastEntry().getComment()
-					.startsWith("revert: "));
-			reader = db.getReflogReader(db.getBranch());
-			assertTrue(reader.getLastEntry().getComment()
-					.startsWith("revert: "));
+			RefDatabase refDb = db.getRefDatabase();
+			ReflogReader reader = refDb.getReflogReader(Constants.HEAD);
+			assertTrue(
+					reader.getLastEntry().getComment().startsWith("revert: "));
+			reader = refDb.getReflogReader(db.getBranch());
+			assertTrue(
+					reader.getLastEntry().getComment().startsWith("revert: "));
 		}
 	}
 }
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashCreateCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashCreateCommandTest.java
index 5d0ab05174..18cd21a5d7 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashCreateCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashCreateCommandTest.java
@@ -409,8 +409,8 @@ public class StashCreateCommandTest extends RepositoryTestCase {
 		assertEquals("content", read(committedFile));
 		validateStashedCommit(stashed);
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		ReflogEntry entry = reader.getLastEntry();
 		assertNotNull(entry);
 		assertEquals(ObjectId.zeroId(), entry.getOldId());
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashDropCommandTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashDropCommandTest.java
index c81731d746..d937579283 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashDropCommandTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/api/StashDropCommandTest.java
@@ -92,8 +92,8 @@ public class StashDropCommandTest extends RepositoryTestCase {
 		stashRef = git.getRepository().exactRef(Constants.R_STASH);
 		assertNull(stashRef);
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		assertNull(reader);
 	}
 
@@ -120,8 +120,8 @@ public class StashDropCommandTest extends RepositoryTestCase {
 		assertNull(git.stashDrop().setAll(true).call());
 		assertNull(git.getRepository().exactRef(Constants.R_STASH));
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		assertNull(reader);
 	}
 
@@ -150,8 +150,8 @@ public class StashDropCommandTest extends RepositoryTestCase {
 		assertNotNull(stashRef);
 		assertEquals(firstStash, stashRef.getObjectId());
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		List<ReflogEntry> entries = reader.getReverseEntries();
 		assertEquals(1, entries.size());
 		assertEquals(ObjectId.zeroId(), entries.get(0).getOldId());
@@ -192,8 +192,8 @@ public class StashDropCommandTest extends RepositoryTestCase {
 		assertNotNull(stashRef);
 		assertEquals(thirdStash, stashRef.getObjectId());
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		List<ReflogEntry> entries = reader.getReverseEntries();
 		assertEquals(2, entries.size());
 		assertEquals(ObjectId.zeroId(), entries.get(1).getOldId());
@@ -250,8 +250,8 @@ public class StashDropCommandTest extends RepositoryTestCase {
 		assertNotNull(stashRef);
 		assertEquals(thirdStash, stashRef.getObjectId());
 
-		ReflogReader reader = git.getRepository().getReflogReader(
-				Constants.R_STASH);
+		ReflogReader reader = git.getRepository().getRefDatabase()
+				.getReflogReader(Constants.R_STASH);
 		List<ReflogEntry> entries = reader.getReverseEntries();
 		assertEquals(2, entries.size());
 		assertEquals(ObjectId.zeroId(), entries.get(1).getOldId());
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/BatchRefUpdateTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/BatchRefUpdateTest.java
index 1af42cb229..a0afc3ef13 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/BatchRefUpdateTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/BatchRefUpdateTest.java
@@ -1263,7 +1263,7 @@ public class BatchRefUpdateTest extends LocalDiskRepositoryTestCase {
 	}
 
 	private ReflogEntry getLastReflog(String name) throws IOException {
-		ReflogReader r = diskRepo.getReflogReader(name);
+		ReflogReader r = diskRepo.getRefDatabase().getReflogReader(name);
 		if (r == null) {
 			return null;
 		}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/FileReftableTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/FileReftableTest.java
index 01cbcfd20f..758ee93c30 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/FileReftableTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/FileReftableTest.java
@@ -171,7 +171,8 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		v.update();
 
 		db.convertToPackedRefs(true, false);
-		List<ReflogEntry> logs = db.getReflogReader("refs/heads/master").getReverseEntries(2);
+		List<ReflogEntry> logs = db.getRefDatabase()
+				.getReflogReader("refs/heads/master").getReverseEntries(2);
 		assertEquals("banana", logs.get(0).getComment());
 		assertEquals("apple", logs.get(1).getComment());
 	}
@@ -185,8 +186,9 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		ReceiveCommand rc1 = new ReceiveCommand(ObjectId.zeroId(), cur, "refs/heads/batch1");
 		ReceiveCommand rc2 = new ReceiveCommand(ObjectId.zeroId(), prev, "refs/heads/batch2");
 		String msg =  "message";
+		RefDatabase refDb = db.getRefDatabase();
 		try (RevWalk rw = new RevWalk(db)) {
-			db.getRefDatabase().newBatchUpdate()
+			refDb.newBatchUpdate()
 					.addCommand(rc1, rc2)
 					.setAtomic(true)
 					.setRefLogIdent(person)
@@ -197,12 +199,14 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		assertEquals(ReceiveCommand.Result.OK, rc1.getResult());
 		assertEquals(ReceiveCommand.Result.OK, rc2.getResult());
 
-		ReflogEntry e = db.getReflogReader("refs/heads/batch1").getLastEntry();
+		ReflogEntry e = refDb.getReflogReader("refs/heads/batch1")
+				.getLastEntry();
 		assertEquals(msg, e.getComment());
 		assertEquals(person, e.getWho());
 		assertEquals(cur, e.getNewId());
 
-		e = db.getReflogReader("refs/heads/batch2").getLastEntry();
+		e = refDb.getReflogReader("refs/heads/batch2")
+				.getLastEntry();
 		assertEquals(msg, e.getComment());
 		assertEquals(person, e.getWho());
 		assertEquals(prev, e.getNewId());
@@ -309,7 +313,7 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 
 		// the branch HEAD referred to is left untouched
 		assertEquals(pid, db.resolve("refs/heads/master"));
-		ReflogReader reflogReader = db.getReflogReader("HEAD");
+		ReflogReader reflogReader = db.getRefDatabase().getReflogReader("HEAD");
 		ReflogEntry e = reflogReader.getReverseEntries().get(0);
 		assertEquals(ppid, e.getNewId());
 		assertEquals("GIT_COMMITTER_EMAIL", e.getWho().getEmailAddress());
@@ -330,7 +334,8 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		updateRef.setForceUpdate(true);
 		RefUpdate.Result update = updateRef.update();
 		assertEquals(FORCED, update); // internal
-		ReflogReader r = db.getReflogReader("refs/heads/master");
+		ReflogReader r = db.getRefDatabase()
+				.getReflogReader("refs/heads/master");
 
 		ReflogEntry e = r.getLastEntry();
 		assertEquals(pid, e.getNewId());
@@ -355,7 +360,8 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		assertEquals(RefUpdate.Result.NO_CHANGE, ref.delete());
 
 		// Differs from RefupdateTest. Deleting a loose ref leaves reflog trail.
-		ReflogReader reader = db.getReflogReader("refs/heads/abc");
+		ReflogReader reader = db.getRefDatabase()
+				.getReflogReader("refs/heads/abc");
 		assertEquals(ObjectId.zeroId(), reader.getReverseEntry(1).getOldId());
 		assertEquals(nonZero, reader.getReverseEntry(1).getNewId());
 		assertEquals(nonZero, reader.getReverseEntry(0).getOldId());
@@ -382,8 +388,9 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		assertNotSame(newid, r.getObjectId());
 		assertSame(ObjectId.class, r.getObjectId().getClass());
 		assertEquals(newid, r.getObjectId());
-		List<ReflogEntry> reverseEntries1 = db.getReflogReader("refs/heads/abc")
-				.getReverseEntries();
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> reverseEntries1 = refDb
+				.getReflogReader("refs/heads/abc").getReverseEntries();
 		ReflogEntry entry1 = reverseEntries1.get(0);
 		assertEquals(1, reverseEntries1.size());
 		assertEquals(ObjectId.zeroId(), entry1.getOldId());
@@ -392,7 +399,7 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		assertEquals(new PersonIdent(db).toString(),
 				entry1.getWho().toString());
 		assertEquals("", entry1.getComment());
-		List<ReflogEntry> reverseEntries2 = db.getReflogReader("HEAD")
+		List<ReflogEntry> reverseEntries2 = refDb.getReflogReader("HEAD")
 				.getReverseEntries();
 		assertEquals(0, reverseEntries2.size());
 	}
@@ -455,7 +462,7 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 
 		// the branch HEAD referred to is left untouched
 		assertNull(db.resolve("refs/heads/unborn"));
-		ReflogReader reflogReader = db.getReflogReader("HEAD");
+		ReflogReader reflogReader = db.getRefDatabase().getReflogReader("HEAD");
 		ReflogEntry e = reflogReader.getReverseEntries().get(0);
 		assertEquals(ObjectId.zeroId(), e.getOldId());
 		assertEquals(ppid, e.getNewId());
@@ -499,7 +506,7 @@ public class FileReftableTest extends SampleDataRepositoryTestCase {
 		names.add("refs/heads/new/name");
 
 		for (String nm : names) {
-			ReflogReader rd = db.getReflogReader(nm);
+			ReflogReader rd = db.getRefDatabase().getReflogReader(nm);
 			assertNotNull(rd);
 			ReflogEntry last = rd.getLastEntry();
 			ObjectId id = last.getNewId();
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/RefUpdateTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/RefUpdateTest.java
index cb977bd601..0a9aa40d04 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/RefUpdateTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/RefUpdateTest.java
@@ -40,6 +40,7 @@ import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectInserter;
 import org.eclipse.jgit.lib.PersonIdent;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.RefRename;
 import org.eclipse.jgit.lib.RefUpdate;
 import org.eclipse.jgit.lib.RefUpdate.Result;
@@ -111,16 +112,17 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertNotSame(newid, r.getObjectId());
 		assertSame(ObjectId.class, r.getObjectId().getClass());
 		assertEquals(newid, r.getObjectId());
-		List<ReflogEntry> reverseEntries1 = db
+		List<ReflogEntry> reverseEntries1 = db.getRefDatabase()
 				.getReflogReader("refs/heads/abc").getReverseEntries();
 		ReflogEntry entry1 = reverseEntries1.get(0);
 		assertEquals(1, reverseEntries1.size());
 		assertEquals(ObjectId.zeroId(), entry1.getOldId());
 		assertEquals(r.getObjectId(), entry1.getNewId());
-		assertEquals(new PersonIdent(db).toString(),  entry1.getWho().toString());
+		assertEquals(new PersonIdent(db).toString(),
+				entry1.getWho().toString());
 		assertEquals("", entry1.getComment());
-		List<ReflogEntry> reverseEntries2 = db.getReflogReader("HEAD")
-				.getReverseEntries();
+		List<ReflogEntry> reverseEntries2 = db.getRefDatabase()
+				.getReflogReader("HEAD").getReverseEntries();
 		assertEquals(0, reverseEntries2.size());
 	}
 
@@ -136,8 +138,11 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		final RefUpdate ru2 = updateRef(newRef2);
 		Result update2 = ru2.update();
 		assertEquals(Result.LOCK_FAILURE, update2);
-		assertEquals(1, db.getReflogReader("refs/heads/z").getReverseEntries().size());
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(1, refDb.getReflogReader("refs/heads/z")
+				.getReverseEntries().size());
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	@Test
@@ -147,8 +152,10 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		final RefUpdate ru = updateRef(newRef);
 		Result update = ru.update();
 		assertEquals(Result.LOCK_FAILURE, update);
-		assertNull(db.getReflogReader("refs/heads/master/x"));
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertNull(refDb.getReflogReader("refs/heads/master/x"));
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	@Test
@@ -163,9 +170,12 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		final RefUpdate ru2 = updateRef(newRef2);
 		Result update2 = ru2.update();
 		assertEquals(Result.LOCK_FAILURE, update2);
-		assertEquals(1, db.getReflogReader("refs/heads/z/a").getReverseEntries().size());
-		assertNull(db.getReflogReader("refs/heads/z"));
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(1, refDb.getReflogReader("refs/heads/z/a")
+				.getReverseEntries().size());
+		assertNull(refDb.getReflogReader("refs/heads/z"));
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	@Test
@@ -175,8 +185,10 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		final RefUpdate ru = updateRef(newRef);
 		Result update = ru.update();
 		assertEquals(Result.LOCK_FAILURE, update);
-		assertNull(db.getReflogReader("refs/heads/prefix"));
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertNull(refDb.getReflogReader("refs/heads/prefix"));
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	/**
@@ -197,8 +209,11 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		Result delete = updateRef2.delete();
 		assertEquals(Result.REJECTED_CURRENT_BRANCH, delete);
 		assertEquals(pid, db.resolve("refs/heads/master"));
-		assertEquals(1,db.getReflogReader("refs/heads/master").getReverseEntries().size());
-		assertEquals(0,db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(1, refDb.getReflogReader("refs/heads/master")
+				.getReverseEntries().size());
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	@Test
@@ -209,7 +224,8 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		updateRef.setForceUpdate(true);
 		Result update = updateRef.update();
 		assertEquals(Result.FORCED, update);
-		assertEquals(1,db.getReflogReader("refs/heads/master").getReverseEntries().size());
+		assertEquals(1, db.getRefDatabase().getReflogReader("refs/heads/master")
+				.getReverseEntries().size());
 	}
 
 	@Test
@@ -219,15 +235,18 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		ref.update(); // create loose ref
 		ref = updateRef(newRef); // refresh
 		delete(ref, Result.NO_CHANGE);
-		assertNull(db.getReflogReader("refs/heads/abc"));
+		assertNull(db.getRefDatabase().getReflogReader("refs/heads/abc"));
 	}
 
 	@Test
 	public void testDeleteHead() throws IOException {
 		final RefUpdate ref = updateRef(Constants.HEAD);
 		delete(ref, Result.REJECTED_CURRENT_BRANCH, true, false);
-		assertEquals(0, db.getReflogReader("refs/heads/master").getReverseEntries().size());
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(0, refDb.getReflogReader("refs/heads/master")
+				.getReverseEntries().size());
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 	}
 
 	@Test
@@ -423,7 +442,7 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 
 		// the branch HEAD referred to is left untouched
 		assertEquals(pid, db.resolve("refs/heads/master"));
-		ReflogReader reflogReader = db.getReflogReader("HEAD");
+		ReflogReader reflogReader = db.getRefDatabase().getReflogReader("HEAD");
 		ReflogEntry e = reflogReader.getReverseEntries().get(0);
 		assertEquals(pid, e.getOldId());
 		assertEquals(ppid, e.getNewId());
@@ -453,7 +472,7 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 
 		// the branch HEAD referred to is left untouched
 		assertNull(db.resolve("refs/heads/unborn"));
-		ReflogReader reflogReader = db.getReflogReader("HEAD");
+		ReflogReader reflogReader = db.getRefDatabase().getReflogReader("HEAD");
 		ReflogEntry e = reflogReader.getReverseEntries().get(0);
 		assertEquals(ObjectId.zeroId(), e.getOldId());
 		assertEquals(ppid, e.getNewId());
@@ -691,9 +710,11 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertEquals(Result.RENAMED, result);
 		assertEquals(rb, db.resolve("refs/heads/new/name"));
 		assertNull(db.resolve("refs/heads/b"));
-		assertEquals(1, db.getReflogReader("new/name").getReverseEntries().size());
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader("new/name")
-				.getLastEntry().getComment());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(1,
+				refDb.getReflogReader("new/name").getReverseEntries().size());
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("new/name").getLastEntry().getComment());
 		assertFalse(new File(db.getDirectory(), "logs/refs/heads/b").exists());
 		assertEquals(oldHead, db.resolve(Constants.HEAD)); // unchanged
 	}
@@ -713,10 +734,12 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertEquals(Result.RENAMED, result);
 		assertEquals(rb, db.resolve("refs/heads/new/name"));
 		assertNull(db.resolve("refs/heads/b"));
-		assertEquals(2, db.getReflogReader("new/name").getReverseEntries().size());
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader("new/name")
-				.getLastEntry().getComment());
-		assertEquals("Just a message", db.getReflogReader("new/name")
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(2,
+				refDb.getReflogReader("new/name").getReverseEntries().size());
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("new/name").getLastEntry().getComment());
+		assertEquals("Just a message", refDb.getReflogReader("new/name")
 				.getReverseEntries().get(1).getComment());
 		assertFalse(new File(db.getDirectory(), "logs/refs/heads/b").exists());
 		assertEquals(oldHead, db.resolve(Constants.HEAD)); // unchanged
@@ -737,13 +760,18 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertEquals(Result.RENAMED, result);
 		assertEquals(rb, db.resolve("refs/heads/new/name"));
 		assertNull(db.resolve("refs/heads/b"));
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader(
-				"new/name").getLastEntry().getComment());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("new/name").getLastEntry().getComment());
 		assertFalse(new File(db.getDirectory(), "logs/refs/heads/b").exists());
 		assertEquals(rb, db.resolve(Constants.HEAD));
-		assertEquals(2, db.getReflogReader("new/name").getReverseEntries().size());
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader("new/name").getReverseEntries().get(0).getComment());
-		assertEquals("Just a message", db.getReflogReader("new/name").getReverseEntries().get(1).getComment());
+		assertEquals(2,
+				refDb.getReflogReader("new/name").getReverseEntries().size());
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("new/name").getReverseEntries().get(0)
+						.getComment());
+		assertEquals("Just a message", refDb.getReflogReader("new/name")
+				.getReverseEntries().get(1).getComment());
 	}
 
 	@Test
@@ -766,11 +794,16 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertEquals(Result.RENAMED, result);
 		assertEquals(rb2, db.resolve("refs/heads/new/name"));
 		assertNull(db.resolve("refs/heads/b"));
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader(
-				"new/name").getLastEntry().getComment());
-		assertEquals(3, db.getReflogReader("refs/heads/new/name").getReverseEntries().size());
-		assertEquals("Branch: renamed b to new/name", db.getReflogReader("refs/heads/new/name").getReverseEntries().get(0).getComment());
-		assertEquals(0, db.getReflogReader("HEAD").getReverseEntries().size());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("new/name").getLastEntry().getComment());
+		assertEquals(3, refDb.getReflogReader("refs/heads/new/name")
+				.getReverseEntries().size());
+		assertEquals("Branch: renamed b to new/name",
+				refDb.getReflogReader("refs/heads/new/name").getReverseEntries()
+						.get(0).getComment());
+		assertEquals(0,
+				refDb.getReflogReader("HEAD").getReverseEntries().size());
 		// make sure b's log file is gone too.
 		assertFalse(new File(db.getDirectory(), "logs/refs/heads/b").exists());
 
@@ -789,9 +822,10 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		ObjectId oldfromId = db.resolve(fromName);
 		ObjectId oldHeadId = db.resolve(Constants.HEAD);
 		writeReflog(db, oldfromId, "Just a message", fromName);
-		List<ReflogEntry> oldFromLog = db
+		RefDatabase refDb = db.getRefDatabase();
+		List<ReflogEntry> oldFromLog = refDb
 				.getReflogReader(fromName).getReverseEntries();
-		List<ReflogEntry> oldHeadLog = oldHeadId != null ? db
+		List<ReflogEntry> oldHeadLog = oldHeadId != null ? refDb
 				.getReflogReader(Constants.HEAD).getReverseEntries() : null;
 
 		assertTrue("internal check, we have a log", new File(db.getDirectory(),
@@ -818,10 +852,10 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 			assertEquals(oldHeadId, db.resolve(Constants.HEAD));
 			assertEquals(oldfromId, db.resolve(fromName));
 			assertNull(db.resolve(toName));
-			assertEquals(oldFromLog.toString(), db.getReflogReader(fromName)
+			assertEquals(oldFromLog.toString(), refDb.getReflogReader(fromName)
 					.getReverseEntries().toString());
 			if (oldHeadId != null && oldHeadLog != null)
-				assertEquals(oldHeadLog.toString(), db.getReflogReader(
+				assertEquals(oldHeadLog.toString(), refDb.getReflogReader(
 						Constants.HEAD).getReverseEntries().toString());
 		} finally {
 			lockFile.unlock();
@@ -942,15 +976,17 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 		assertEquals(Result.RENAMED, result);
 		assertNull(db.resolve("refs/heads/a"));
 		assertEquals(rb, db.resolve("refs/heads/a/b"));
-		assertEquals(3, db.getReflogReader("a/b").getReverseEntries().size());
-		assertEquals("Branch: renamed a to a/b", db.getReflogReader("a/b")
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(3,
+				refDb.getReflogReader("a/b").getReverseEntries().size());
+		assertEquals("Branch: renamed a to a/b", refDb.getReflogReader("a/b")
 				.getReverseEntries().get(0).getComment());
-		assertEquals("Just a message", db.getReflogReader("a/b")
+		assertEquals("Just a message", refDb.getReflogReader("a/b")
 				.getReverseEntries().get(1).getComment());
-		assertEquals("Setup", db.getReflogReader("a/b").getReverseEntries()
+		assertEquals("Setup", refDb.getReflogReader("a/b").getReverseEntries()
 				.get(2).getComment());
 		// same thing was logged to HEAD
-		assertEquals("Branch: renamed a to a/b", db.getReflogReader("HEAD")
+		assertEquals("Branch: renamed a to a/b", refDb.getReflogReader("HEAD")
 				.getReverseEntries().get(0).getComment());
 	}
 
@@ -978,15 +1014,19 @@ public class RefUpdateTest extends SampleDataRepositoryTestCase {
 
 		assertNull(db.resolve("refs/heads/prefix/a"));
 		assertEquals(rb, db.resolve("refs/heads/prefix"));
-		assertEquals(3, db.getReflogReader("prefix").getReverseEntries().size());
-		assertEquals("Branch: renamed prefix/a to prefix", db.getReflogReader(
-				"prefix").getReverseEntries().get(0).getComment());
-		assertEquals("Just a message", db.getReflogReader("prefix")
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(3,
+				refDb.getReflogReader("prefix").getReverseEntries().size());
+		assertEquals("Branch: renamed prefix/a to prefix",
+				refDb.getReflogReader("prefix").getReverseEntries().get(0)
+						.getComment());
+		assertEquals("Just a message", refDb.getReflogReader("prefix")
 				.getReverseEntries().get(1).getComment());
-		assertEquals("Setup", db.getReflogReader("prefix").getReverseEntries()
-				.get(2).getComment());
-		assertEquals("Branch: renamed prefix/a to prefix", db.getReflogReader(
-				"HEAD").getReverseEntries().get(0).getComment());
+		assertEquals("Setup", refDb.getReflogReader("prefix")
+				.getReverseEntries().get(2).getComment());
+		assertEquals("Branch: renamed prefix/a to prefix",
+				refDb.getReflogReader("HEAD").getReverseEntries().get(0)
+						.getComment());
 	}
 
 	@Test
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/ReflogReaderTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/ReflogReaderTest.java
index eb521ff9eb..23c279eabe 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/ReflogReaderTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/file/ReflogReaderTest.java
@@ -27,6 +27,7 @@ import org.eclipse.jgit.lib.CheckoutEntry;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.ReflogEntry;
 import org.eclipse.jgit.lib.ReflogReader;
 import org.eclipse.jgit.test.resources.SampleDataRepositoryTestCase;
@@ -154,18 +155,20 @@ public class ReflogReaderTest extends SampleDataRepositoryTestCase {
 		setupReflog("logs/refs/heads/a", aLine);
 		setupReflog("logs/refs/heads/master", masterLine);
 		setupReflog("logs/HEAD", headLine);
-		assertEquals("branch: change to master", db.getReflogReader("master")
-				.getLastEntry().getComment());
-		assertEquals("branch: change to a", db.getReflogReader("a")
-				.getLastEntry().getComment());
-		assertEquals("branch: change to HEAD", db.getReflogReader("HEAD")
-				.getLastEntry().getComment());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals("branch: change to master",
+				refDb.getReflogReader("master").getLastEntry().getComment());
+		assertEquals("branch: change to a",
+				refDb.getReflogReader("a").getLastEntry().getComment());
+		assertEquals("branch: change to HEAD",
+				refDb.getReflogReader("HEAD").getLastEntry().getComment());
 	}
 
 	@Test
 	public void testReadLineWithMissingComment() throws Exception {
 		setupReflog("logs/refs/heads/master", oneLineWithoutComment);
-		final ReflogReader reader = db.getReflogReader("master");
+		final ReflogReader reader = db.getRefDatabase()
+				.getReflogReader("master");
 		ReflogEntry e = reader.getLastEntry();
 		assertEquals(ObjectId
 				.fromString("da85355dfc525c9f6f3927b876f379f46ccf826e"), e
@@ -183,15 +186,17 @@ public class ReflogReaderTest extends SampleDataRepositoryTestCase {
 
 	@Test
 	public void testNoLog() throws Exception {
-		assertEquals(0, db.getReflogReader("master").getReverseEntries().size());
-		assertNull(db.getReflogReader("master").getLastEntry());
+		RefDatabase refDb = db.getRefDatabase();
+		assertEquals(0,
+				refDb.getReflogReader("master").getReverseEntries().size());
+		assertNull(refDb.getReflogReader("master").getLastEntry());
 	}
 
 	@Test
 	public void testCheckout() throws Exception {
 		setupReflog("logs/HEAD", switchBranch);
-		List<ReflogEntry> entries = db.getReflogReader(Constants.HEAD)
-				.getReverseEntries();
+		List<ReflogEntry> entries = db.getRefDatabase()
+				.getReflogReader(Constants.HEAD).getReverseEntries();
 		assertEquals(1, entries.size());
 		ReflogEntry entry = entries.get(0);
 		CheckoutEntry checkout = entry.parseCheckout();
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java
index ad47cef0f4..a93937eeea 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReflogConfigTest.java
@@ -32,7 +32,8 @@ public class ReflogConfigTest extends RepositoryTestCase {
 
 		// check that there are no entries in the reflog and turn off writing
 		// reflogs
-		assertTrue(db.getReflogReader(Constants.HEAD).getReverseEntries()
+		RefDatabase refDb = db.getRefDatabase();
+		assertTrue(refDb.getReflogReader(Constants.HEAD).getReverseEntries()
 				.isEmpty());
 		FileBasedConfig cfg = db.getConfig();
 		cfg.setBoolean("core", null, "logallrefupdates", false);
@@ -42,7 +43,7 @@ public class ReflogConfigTest extends RepositoryTestCase {
 		// written
 		commit("A Commit\n", commitTime, tz);
 		commitTime = commitTime.plus(Duration.ofMinutes(1));
-		assertTrue("Reflog for HEAD still contain no entry", db
+		assertTrue("Reflog for HEAD still contain no entry", refDb
 				.getReflogReader(Constants.HEAD).getReverseEntries().isEmpty());
 
 		// set the logAllRefUpdates parameter to true and check it
@@ -56,9 +57,9 @@ public class ReflogConfigTest extends RepositoryTestCase {
 		// do one commit and check that reflog size is increased to 1
 		commit("A Commit\n", commitTime, tz);
 		commitTime = commitTime.plus(Duration.ofMinutes(1));
-		assertTrue(
-				"Reflog for HEAD should contain one entry",
-				db.getReflogReader(Constants.HEAD).getReverseEntries().size() == 1);
+		assertTrue("Reflog for HEAD should contain one entry",
+				refDb.getReflogReader(Constants.HEAD).getReverseEntries()
+						.size() == 1);
 
 		// set the logAllRefUpdates parameter to false and check it
 		cfg.setBoolean("core", null, "logallrefupdates", false);
@@ -71,9 +72,9 @@ public class ReflogConfigTest extends RepositoryTestCase {
 		// do one commit and check that reflog size is 2
 		commit("A Commit\n", commitTime, tz);
 		commitTime = commitTime.plus(Duration.ofMinutes(1));
-		assertTrue(
-				"Reflog for HEAD should contain two entries",
-				db.getReflogReader(Constants.HEAD).getReverseEntries().size() == 2);
+		assertTrue("Reflog for HEAD should contain two entries",
+				refDb.getReflogReader(Constants.HEAD).getReverseEntries()
+						.size() == 2);
 
 		// set the logAllRefUpdates parameter to false and check it
 		cfg.setEnum("core", null, "logallrefupdates",
@@ -87,7 +88,7 @@ public class ReflogConfigTest extends RepositoryTestCase {
 		// do one commit and check that reflog size is 3
 		commit("A Commit\n", commitTime, tz);
 		assertTrue("Reflog for HEAD should contain three entries",
-				db.getReflogReader(Constants.HEAD).getReverseEntries()
+				refDb.getReflogReader(Constants.HEAD).getReverseEntries()
 						.size() == 3);
 	}
 
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/ReflogCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/ReflogCommand.java
index dead2749b7..a149649004 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/ReflogCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/ReflogCommand.java
@@ -68,7 +68,7 @@ public class ReflogCommand extends GitCommand<Collection<ReflogEntry>> {
 		checkCallable();
 
 		try {
-			ReflogReader reader = repo.getReflogReader(ref);
+			ReflogReader reader = repo.getRefDatabase().getReflogReader(ref);
 			if (reader == null)
 				throw new RefNotFoundException(MessageFormat.format(
 						JGitText.get().refNotResolved, ref));
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashDropCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashDropCommand.java
index 23fbe0197f..2dba0ef0f2 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashDropCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashDropCommand.java
@@ -165,7 +165,8 @@ public class StashDropCommand extends GitCommand<ObjectId> {
 
 		List<ReflogEntry> entries;
 		try {
-			ReflogReader reader = repo.getReflogReader(R_STASH);
+			ReflogReader reader = repo.getRefDatabase()
+					.getReflogReader(R_STASH);
 			if (reader == null) {
 				throw new RefNotFoundException(MessageFormat
 						.format(JGitText.get().refNotResolved, stashRef));
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileReftableDatabase.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileReftableDatabase.java
index 81e8c0306d..3b09d3a82f 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileReftableDatabase.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileReftableDatabase.java
@@ -563,9 +563,10 @@ public class FileReftableDatabase extends RefDatabase {
 			boolean writeLogs) throws IOException {
 		int size = 0;
 		List<Ref> refs = repo.getRefDatabase().getRefs();
+		RefDatabase refDb = repo.getRefDatabase();
 		if (writeLogs) {
 			for (Ref r : refs) {
-				ReflogReader rlr = repo.getReflogReader(r.getName());
+				ReflogReader rlr = refDb.getReflogReader(r.getName());
 				if (rlr != null) {
 					size = Math.max(rlr.getReverseEntries().size(), size);
 				}
@@ -588,7 +589,7 @@ public class FileReftableDatabase extends RefDatabase {
 		if (writeLogs) {
 			for (Ref r : refs) {
 				long idx = size;
-				ReflogReader reader = repo.getReflogReader(r.getName());
+				ReflogReader reader = refDb.getReflogReader(r.getName());
 				if (reader == null) {
 					continue;
 				}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
index 09cf35a0cf..15679aa64e 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
@@ -1157,7 +1157,7 @@ public class GC {
 	 *             if an IO error occurred
 	 */
 	private Set<ObjectId> listRefLogObjects(Ref ref, long minTime) throws IOException {
-		ReflogReader reflogReader = repo.getReflogReader(ref);
+		ReflogReader reflogReader = repo.getRefDatabase().getReflogReader(ref);
 		List<ReflogEntry> rlEntries = reflogReader
 				.getReverseEntries();
 		if (rlEntries == null || rlEntries.isEmpty())
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
index a7bba23996..757473878b 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
@@ -1692,7 +1692,9 @@ public abstract class Repository implements AutoCloseable {
 	 * @throws java.io.IOException
 	 *             the ref could not be accessed.
 	 * @since 3.0
+	 * @deprecated use {@code #getRefDatabase().getReflogReader(String)} instead
 	 */
+	@Deprecated(since = "7.2")
 	@Nullable
 	public ReflogReader getReflogReader(String refName) throws IOException {
 		return getRefDatabase().getReflogReader(refName);
@@ -1708,7 +1710,9 @@ public abstract class Repository implements AutoCloseable {
 	 * @throws IOException
 	 *             if an IO error occurred
 	 * @since 5.13.2
+	 * @deprecated use {@code #getRefDatabase().getReflogReader(Ref)} instead
 	 */
+	@Deprecated(since = "7.2")
 	@NonNull
 	public ReflogReader getReflogReader(@NonNull Ref ref)
 			throws IOException {