Rename PackFile to Pack
Pack better represents the purpose of the object and paves the way to add a PackFile object that extends File. Change-Id: I39b4f697902d395e9b6df5e8ce53078ce72fcea3 Signed-off-by: Nasser Grainawi <quic_nasserg@quicinc.com>
This commit is contained in:
Nasser Grainawi
parent
fe4b2a4656
commit
efb154fc24
|
|
@ -20,7 +20,7 @@
|
|||
import javax.servlet.http.HttpServletResponse;
|
||||
|
||||
import org.eclipse.jgit.internal.storage.file.ObjectDirectory;
|
||||
import org.eclipse.jgit.internal.storage.file.PackFile;
|
||||
import org.eclipse.jgit.internal.storage.file.Pack;
|
||||
import org.eclipse.jgit.lib.ObjectDatabase;
|
||||
|
||||
/** Sends the current list of pack files, sorted most recent first. */
|
||||
|
|
@ -38,7 +38,7 @@ private static String packList(HttpServletRequest req) {
|
|||
final StringBuilder out = new StringBuilder();
|
||||
final ObjectDatabase db = getRepository(req).getObjectDatabase();
|
||||
if (db instanceof ObjectDirectory) {
|
||||
for (PackFile pack : ((ObjectDirectory) db).getPacks()) {
|
||||
for (Pack pack : ((ObjectDirectory) db).getPacks()) {
|
||||
out.append("P ");
|
||||
out.append(pack.getPackFile().getName());
|
||||
out.append('\n');
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@
|
|||
import org.eclipse.jgit.internal.storage.file.FileRepository;
|
||||
import org.eclipse.jgit.internal.storage.file.LockFile;
|
||||
import org.eclipse.jgit.internal.storage.file.ObjectDirectory;
|
||||
import org.eclipse.jgit.internal.storage.file.PackFile;
|
||||
import org.eclipse.jgit.internal.storage.file.Pack;
|
||||
import org.eclipse.jgit.internal.storage.file.PackIndex.MutableEntry;
|
||||
import org.eclipse.jgit.internal.storage.pack.PackWriter;
|
||||
import org.eclipse.jgit.lib.AnyObjectId;
|
||||
|
|
@ -773,7 +773,7 @@ protected void writeFile(String name, byte[] bin)
|
|||
rw.writeInfoRefs();
|
||||
|
||||
final StringBuilder w = new StringBuilder();
|
||||
for (PackFile p : fr.getObjectDatabase().getPacks()) {
|
||||
for (Pack p : fr.getObjectDatabase().getPacks()) {
|
||||
w.append("P ");
|
||||
w.append(p.getPackFile().getName());
|
||||
w.append('\n');
|
||||
|
|
@ -954,7 +954,7 @@ public void close() {
|
|||
}
|
||||
|
||||
private static void prunePacked(ObjectDirectory odb) throws IOException {
|
||||
for (PackFile p : odb.getPacks()) {
|
||||
for (Pack p : odb.getPacks()) {
|
||||
for (MutableEntry e : p)
|
||||
FileUtils.delete(odb.fileFor(e.toObjectId()));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ public void testNotPackTwice(boolean aggressive) throws Exception {
|
|||
.create();
|
||||
tr.update("refs/tags/t1", second);
|
||||
|
||||
Collection<PackFile> oldPacks = tr.getRepository().getObjectDatabase()
|
||||
Collection<Pack> oldPacks = tr.getRepository().getObjectDatabase()
|
||||
.getPacks();
|
||||
assertEquals(0, oldPacks.size());
|
||||
stats = gc.getStatistics();
|
||||
|
|
@ -171,7 +171,7 @@ public void testNotPackTwice(boolean aggressive) throws Exception {
|
|||
stats = gc.getStatistics();
|
||||
assertEquals(0, stats.numberOfLooseObjects);
|
||||
|
||||
List<PackFile> packs = new ArrayList<>(
|
||||
List<Pack> packs = new ArrayList<>(
|
||||
repo.getObjectDatabase().getPacks());
|
||||
assertEquals(11, packs.get(0).getObjectCount());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -156,8 +156,8 @@ public void repackAndUploadPack() throws Exception {
|
|||
}
|
||||
}
|
||||
|
||||
PackFile getSinglePack(FileRepository r) {
|
||||
Collection<PackFile> packs = r.getObjectDatabase().getPacks();
|
||||
Pack getSinglePack(FileRepository r) {
|
||||
Collection<Pack> packs = r.getObjectDatabase().getPacks();
|
||||
assertEquals(1, packs.size());
|
||||
return packs.iterator().next();
|
||||
}
|
||||
|
|
@ -206,11 +206,11 @@ public void testInterruptGc() throws Exception {
|
|||
SampleDataRepositoryTestCase.copyCGitTestPacks(repo);
|
||||
ExecutorService executor = Executors.newSingleThreadExecutor();
|
||||
final CountDownLatch latch = new CountDownLatch(1);
|
||||
Future<Collection<PackFile>> result = executor.submit(() -> {
|
||||
Future<Collection<Pack>> result = executor.submit(() -> {
|
||||
long start = System.currentTimeMillis();
|
||||
System.out.println("starting gc");
|
||||
latch.countDown();
|
||||
Collection<PackFile> r = gc.gc();
|
||||
Collection<Pack> r = gc.gc();
|
||||
System.out.println(
|
||||
"gc took " + (System.currentTimeMillis() - start) + " ms");
|
||||
return r;
|
||||
|
|
|
|||
|
|
@ -36,9 +36,9 @@ public void testKeepFiles() throws Exception {
|
|||
assertEquals(4, stats.numberOfPackedObjects);
|
||||
assertEquals(1, stats.numberOfPackFiles);
|
||||
|
||||
Iterator<PackFile> packIt = repo.getObjectDatabase().getPacks()
|
||||
Iterator<Pack> packIt = repo.getObjectDatabase().getPacks()
|
||||
.iterator();
|
||||
PackFile singlePack = packIt.next();
|
||||
Pack singlePack = packIt.next();
|
||||
assertFalse(packIt.hasNext());
|
||||
String packFileName = singlePack.getPackFile().getPath();
|
||||
String keepFileName = packFileName.substring(0,
|
||||
|
|
@ -58,7 +58,7 @@ public void testKeepFiles() throws Exception {
|
|||
assertEquals(2, stats.numberOfPackFiles);
|
||||
|
||||
// check that no object is packed twice
|
||||
Iterator<PackFile> packs = repo.getObjectDatabase().getPacks()
|
||||
Iterator<Pack> packs = repo.getObjectDatabase().getPacks()
|
||||
.iterator();
|
||||
PackIndex ind1 = packs.next().getIndex();
|
||||
assertEquals(4, ind1.getObjectCount());
|
||||
|
|
|
|||
|
|
@ -72,14 +72,14 @@ public void testSamePackDifferentCompressionDetectChecksumChanged()
|
|||
c.setInt(ConfigConstants.CONFIG_GC_SECTION, null,
|
||||
ConfigConstants.CONFIG_KEY_AUTOPACKLIMIT, 1);
|
||||
c.save();
|
||||
Collection<PackFile> packs = gc(Deflater.NO_COMPRESSION);
|
||||
Collection<Pack> packs = gc(Deflater.NO_COMPRESSION);
|
||||
assertEquals("expected 1 packfile after gc", 1, packs.size());
|
||||
PackFile p1 = packs.iterator().next();
|
||||
Pack p1 = packs.iterator().next();
|
||||
PackFileSnapshot snapshot = p1.getFileSnapshot();
|
||||
|
||||
packs = gc(Deflater.BEST_COMPRESSION);
|
||||
assertEquals("expected 1 packfile after gc", 1, packs.size());
|
||||
PackFile p2 = packs.iterator().next();
|
||||
Pack p2 = packs.iterator().next();
|
||||
File pf = p2.getPackFile();
|
||||
|
||||
// changing compression level with aggressive gc may change size,
|
||||
|
|
@ -153,11 +153,11 @@ public void testDetectModificationAlthoughSameSizeAndModificationtime()
|
|||
createTestRepo(testDataSeed, testDataLength);
|
||||
|
||||
// repack to create initial packfile
|
||||
PackFile pf = repackAndCheck(5, null, null, null);
|
||||
Path packFilePath = pf.getPackFile().toPath();
|
||||
AnyObjectId chk1 = pf.getPackChecksum();
|
||||
String name = pf.getPackName();
|
||||
Long length = Long.valueOf(pf.getPackFile().length());
|
||||
Pack p = repackAndCheck(5, null, null, null);
|
||||
Path packFilePath = p.getPackFile().toPath();
|
||||
AnyObjectId chk1 = p.getPackChecksum();
|
||||
String name = p.getPackName();
|
||||
Long length = Long.valueOf(p.getPackFile().length());
|
||||
FS fs = db.getFS();
|
||||
Instant m1 = fs.lastModifiedInstant(packFilePath);
|
||||
|
||||
|
|
@ -207,16 +207,16 @@ public void testDetectModificationAlthoughSameSizeAndModificationtimeAndFileKey(
|
|||
createTestRepo(testDataSeed, testDataLength);
|
||||
|
||||
// Repack to create initial packfile. Make a copy of it
|
||||
PackFile pf = repackAndCheck(5, null, null, null);
|
||||
Path packFilePath = pf.getPackFile().toPath();
|
||||
Pack p = repackAndCheck(5, null, null, null);
|
||||
Path packFilePath = p.getPackFile().toPath();
|
||||
Path fn = packFilePath.getFileName();
|
||||
assertNotNull(fn);
|
||||
String packFileName = fn.toString();
|
||||
Path packFileBasePath = packFilePath
|
||||
.resolveSibling(packFileName.replaceAll(".pack", ""));
|
||||
AnyObjectId chk1 = pf.getPackChecksum();
|
||||
String name = pf.getPackName();
|
||||
Long length = Long.valueOf(pf.getPackFile().length());
|
||||
AnyObjectId chk1 = p.getPackChecksum();
|
||||
String name = p.getPackName();
|
||||
Long length = Long.valueOf(p.getPackFile().length());
|
||||
copyPack(packFileBasePath, "", ".copy1");
|
||||
|
||||
// Repack to create second packfile. Make a copy of it
|
||||
|
|
@ -280,10 +280,10 @@ private Path copyPack(Path base, String srcSuffix, String dstSuffix)
|
|||
Paths.get(base + ".pack" + dstSuffix));
|
||||
}
|
||||
|
||||
private PackFile repackAndCheck(int compressionLevel, String oldName,
|
||||
private Pack repackAndCheck(int compressionLevel, String oldName,
|
||||
Long oldLength, AnyObjectId oldChkSum)
|
||||
throws IOException, ParseException {
|
||||
PackFile p = getSinglePack(gc(compressionLevel));
|
||||
Pack p = getSinglePack(gc(compressionLevel));
|
||||
File pf = p.getPackFile();
|
||||
// The following two assumptions should not cause the test to fail. If
|
||||
// on a certain platform we get packfiles (containing the same git
|
||||
|
|
@ -298,14 +298,14 @@ private PackFile repackAndCheck(int compressionLevel, String oldName,
|
|||
return p;
|
||||
}
|
||||
|
||||
private PackFile getSinglePack(Collection<PackFile> packs) {
|
||||
Iterator<PackFile> pIt = packs.iterator();
|
||||
PackFile p = pIt.next();
|
||||
private Pack getSinglePack(Collection<Pack> packs) {
|
||||
Iterator<Pack> pIt = packs.iterator();
|
||||
Pack p = pIt.next();
|
||||
assertFalse(pIt.hasNext());
|
||||
return p;
|
||||
}
|
||||
|
||||
private Collection<PackFile> gc(int compressionLevel)
|
||||
private Collection<Pack> gc(int compressionLevel)
|
||||
throws IOException, ParseException {
|
||||
GC gc = new GC(db);
|
||||
PackConfig pc = new PackConfig(db.getConfig());
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ public void singlePack() throws Exception {
|
|||
}
|
||||
|
||||
assertPacksOnly();
|
||||
List<PackFile> packs = listPacks();
|
||||
List<Pack> packs = listPacks();
|
||||
assertEquals(1, packs.size());
|
||||
assertEquals(3, packs.get(0).getObjectCount());
|
||||
|
||||
|
|
@ -193,7 +193,7 @@ public void multiplePacks() throws Exception {
|
|||
}
|
||||
|
||||
assertPacksOnly();
|
||||
List<PackFile> packs = listPacks();
|
||||
List<Pack> packs = listPacks();
|
||||
assertEquals(2, packs.size());
|
||||
assertEquals(1, packs.get(0).getObjectCount());
|
||||
assertEquals(1, packs.get(1).getObjectCount());
|
||||
|
|
@ -216,9 +216,9 @@ public void largeBlob() throws Exception {
|
|||
}
|
||||
|
||||
assertPacksOnly();
|
||||
Collection<PackFile> packs = listPacks();
|
||||
Collection<Pack> packs = listPacks();
|
||||
assertEquals(1, packs.size());
|
||||
PackFile p = packs.iterator().next();
|
||||
Pack p = packs.iterator().next();
|
||||
assertEquals(1, p.getObjectCount());
|
||||
|
||||
try (ObjectReader reader = db.newObjectReader()) {
|
||||
|
|
@ -237,9 +237,9 @@ public void overwriteExistingPack() throws Exception {
|
|||
}
|
||||
|
||||
assertPacksOnly();
|
||||
List<PackFile> packs = listPacks();
|
||||
List<Pack> packs = listPacks();
|
||||
assertEquals(1, packs.size());
|
||||
PackFile pack = packs.get(0);
|
||||
Pack pack = packs.get(0);
|
||||
assertEquals(1, pack.getObjectCount());
|
||||
|
||||
String inode = getInode(pack.getPackFile());
|
||||
|
|
@ -372,7 +372,7 @@ public void readBackSmallFiles() throws Exception {
|
|||
}
|
||||
|
||||
assertPacksOnly();
|
||||
List<PackFile> packs = listPacks();
|
||||
List<Pack> packs = listPacks();
|
||||
assertEquals(1, packs.size());
|
||||
assertEquals(2, packs.get(0).getObjectCount());
|
||||
|
||||
|
|
@ -489,16 +489,16 @@ public void readBackSmallObjectBeforeLargeObject() throws Exception {
|
|||
}
|
||||
}
|
||||
|
||||
private List<PackFile> listPacks() throws Exception {
|
||||
List<PackFile> fromOpenDb = listPacks(db);
|
||||
List<PackFile> reopened;
|
||||
private List<Pack> listPacks() throws Exception {
|
||||
List<Pack> fromOpenDb = listPacks(db);
|
||||
List<Pack> reopened;
|
||||
try (FileRepository db2 = new FileRepository(db.getDirectory())) {
|
||||
reopened = listPacks(db2);
|
||||
}
|
||||
assertEquals(fromOpenDb.size(), reopened.size());
|
||||
for (int i = 0 ; i < fromOpenDb.size(); i++) {
|
||||
PackFile a = fromOpenDb.get(i);
|
||||
PackFile b = reopened.get(i);
|
||||
Pack a = fromOpenDb.get(i);
|
||||
Pack b = reopened.get(i);
|
||||
assertEquals(a.getPackName(), b.getPackName());
|
||||
assertEquals(
|
||||
a.getPackFile().getAbsolutePath(), b.getPackFile().getAbsolutePath());
|
||||
|
|
@ -508,9 +508,9 @@ private List<PackFile> listPacks() throws Exception {
|
|||
return fromOpenDb;
|
||||
}
|
||||
|
||||
private static List<PackFile> listPacks(FileRepository db) throws Exception {
|
||||
private static List<Pack> listPacks(FileRepository db) throws Exception {
|
||||
return db.getObjectDatabase().getPacks().stream()
|
||||
.sorted(comparing(PackFile::getPackName)).collect(toList());
|
||||
.sorted(comparing(Pack::getPackName)).collect(toList());
|
||||
}
|
||||
|
||||
private PackInserter newInserter() {
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@
|
|||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class PackFileTest extends LocalDiskRepositoryTestCase {
|
||||
public class PackTest extends LocalDiskRepositoryTestCase {
|
||||
private int streamThreshold = 16 * 1024;
|
||||
|
||||
private TestRng rng;
|
||||
|
|
@ -228,21 +228,21 @@ public void testDelta_FailsOver2GiB() throws Exception {
|
|||
PackedObjectInfo a = new PackedObjectInfo(idA);
|
||||
PackedObjectInfo b = new PackedObjectInfo(idB);
|
||||
|
||||
TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(64 * 1024);
|
||||
packHeader(pack, 2);
|
||||
a.setOffset(pack.length());
|
||||
objectHeader(pack, Constants.OBJ_BLOB, base.length);
|
||||
deflate(pack, base);
|
||||
TemporaryBuffer.Heap packContents = new TemporaryBuffer.Heap(64 * 1024);
|
||||
packHeader(packContents, 2);
|
||||
a.setOffset(packContents.length());
|
||||
objectHeader(packContents, Constants.OBJ_BLOB, base.length);
|
||||
deflate(packContents, base);
|
||||
|
||||
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
|
||||
DeltaEncoder de = new DeltaEncoder(tmp, base.length, 3L << 30);
|
||||
de.copy(0, 1);
|
||||
byte[] delta = tmp.toByteArray();
|
||||
b.setOffset(pack.length());
|
||||
objectHeader(pack, Constants.OBJ_REF_DELTA, delta.length);
|
||||
idA.copyRawTo(pack);
|
||||
deflate(pack, delta);
|
||||
byte[] footer = digest(pack);
|
||||
b.setOffset(packContents.length());
|
||||
objectHeader(packContents, Constants.OBJ_REF_DELTA, delta.length);
|
||||
idA.copyRawTo(packContents);
|
||||
deflate(packContents, delta);
|
||||
byte[] footer = digest(packContents);
|
||||
|
||||
File dir = new File(repo.getObjectDatabase().getDirectory(),
|
||||
"pack");
|
||||
|
|
@ -250,7 +250,7 @@ public void testDelta_FailsOver2GiB() throws Exception {
|
|||
File idxName = new File(dir, idA.name() + ".idx");
|
||||
|
||||
try (FileOutputStream f = new FileOutputStream(packName)) {
|
||||
f.write(pack.toByteArray());
|
||||
f.write(packContents.toByteArray());
|
||||
}
|
||||
|
||||
try (FileOutputStream f = new FileOutputStream(idxName)) {
|
||||
|
|
@ -261,14 +261,14 @@ public void testDelta_FailsOver2GiB() throws Exception {
|
|||
new PackIndexWriterV1(f).write(list, footer);
|
||||
}
|
||||
|
||||
PackFile packFile = new PackFile(packName, PackExt.INDEX.getBit());
|
||||
Pack pack = new Pack(packName, PackExt.INDEX.getBit());
|
||||
try {
|
||||
packFile.get(wc, b);
|
||||
pack.get(wc, b);
|
||||
fail("expected LargeObjectException.ExceedsByteArrayLimit");
|
||||
} catch (LargeObjectException.ExceedsByteArrayLimit bad) {
|
||||
assertNull(bad.getObjectId());
|
||||
} finally {
|
||||
packFile.close();
|
||||
pack.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -72,7 +72,7 @@ public class PackWriterTest extends SampleDataRepositoryTestCase {
|
|||
|
||||
private ByteArrayOutputStream os;
|
||||
|
||||
private PackFile pack;
|
||||
private Pack pack;
|
||||
|
||||
private ObjectInserter inserter;
|
||||
|
||||
|
|
@ -840,7 +840,7 @@ private void verifyOpenPack(boolean thin) throws IOException {
|
|||
p.setAllowThin(thin);
|
||||
p.setIndexVersion(2);
|
||||
p.parse(NullProgressMonitor.INSTANCE);
|
||||
pack = p.getPackFile();
|
||||
pack = p.getPack();
|
||||
assertNotNull("have PackFile after parsing", pack);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,8 +32,8 @@ public void test003_lookupCompressedObject() throws IOException {
|
|||
final ObjectId id;
|
||||
final ObjectLoader or;
|
||||
|
||||
PackFile pr = null;
|
||||
for (PackFile p : db.getObjectDatabase().getPacks()) {
|
||||
Pack pr = null;
|
||||
for (Pack p : db.getObjectDatabase().getPacks()) {
|
||||
if (PACK_NAME.equals(p.getPackName())) {
|
||||
pr = p;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
import org.eclipse.jgit.errors.TooLargeObjectInPackException;
|
||||
import org.eclipse.jgit.internal.JGitText;
|
||||
import org.eclipse.jgit.internal.storage.file.ObjectDirectoryPackParser;
|
||||
import org.eclipse.jgit.internal.storage.file.PackFile;
|
||||
import org.eclipse.jgit.internal.storage.file.Pack;
|
||||
import org.eclipse.jgit.junit.JGitTestUtil;
|
||||
import org.eclipse.jgit.junit.RepositoryTestCase;
|
||||
import org.eclipse.jgit.junit.TestRepository;
|
||||
|
|
@ -63,16 +63,16 @@ public void test1() throws IOException {
|
|||
try (InputStream is = new FileInputStream(packFile)) {
|
||||
ObjectDirectoryPackParser p = (ObjectDirectoryPackParser) index(is);
|
||||
p.parse(NullProgressMonitor.INSTANCE);
|
||||
PackFile file = p.getPackFile();
|
||||
Pack pack = p.getPack();
|
||||
|
||||
assertTrue(file.hasObject(ObjectId.fromString("4b825dc642cb6eb9a060e54bf8d69288fbee4904")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("540a36d136cf413e4b064c2b0e0a4db60f77feab")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("5b6e7c66c276e7610d4a73c70ec1a1f7c1003259")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("6ff87c4664981e4397625791c8ea3bbb5f2279a3")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("902d5476fa249b7abc9d84c611577a81381f0327")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("aabf2ffaec9b497f0950352b3e582d73035c2035")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("c59759f143fb1fe21c197981df75a7ee00290799")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("4b825dc642cb6eb9a060e54bf8d69288fbee4904")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("540a36d136cf413e4b064c2b0e0a4db60f77feab")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("5b6e7c66c276e7610d4a73c70ec1a1f7c1003259")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("6ff87c4664981e4397625791c8ea3bbb5f2279a3")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("902d5476fa249b7abc9d84c611577a81381f0327")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("aabf2ffaec9b497f0950352b3e582d73035c2035")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("c59759f143fb1fe21c197981df75a7ee00290799")));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -88,20 +88,20 @@ public void test2() throws IOException {
|
|||
try (InputStream is = new FileInputStream(packFile)) {
|
||||
ObjectDirectoryPackParser p = (ObjectDirectoryPackParser) index(is);
|
||||
p.parse(NullProgressMonitor.INSTANCE);
|
||||
PackFile file = p.getPackFile();
|
||||
Pack pack = p.getPack();
|
||||
|
||||
assertTrue(file.hasObject(ObjectId.fromString("02ba32d3649e510002c21651936b7077aa75ffa9")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("0966a434eb1a025db6b71485ab63a3bfbea520b6")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("09efc7e59a839528ac7bda9fa020dc9101278680")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("0a3d7772488b6b106fb62813c4d6d627918d9181")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("1004d0d7ac26fbf63050a234c9b88a46075719d3")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("10da5895682013006950e7da534b705252b03be6")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("1203b03dc816ccbb67773f28b3c19318654b0bc8")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("15fae9e651043de0fd1deef588aa3fbf5a7a41c6")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("16f9ec009e5568c435f473ba3a1df732d49ce8c3")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("1fd7d579fb6ae3fe942dc09c2c783443d04cf21e")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("20a8ade77639491ea0bd667bf95de8abf3a434c8")));
|
||||
assertTrue(file.hasObject(ObjectId.fromString("2675188fd86978d5bc4d7211698b2118ae3bf658")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("02ba32d3649e510002c21651936b7077aa75ffa9")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("0966a434eb1a025db6b71485ab63a3bfbea520b6")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("09efc7e59a839528ac7bda9fa020dc9101278680")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("0a3d7772488b6b106fb62813c4d6d627918d9181")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("1004d0d7ac26fbf63050a234c9b88a46075719d3")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("10da5895682013006950e7da534b705252b03be6")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("1203b03dc816ccbb67773f28b3c19318654b0bc8")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("15fae9e651043de0fd1deef588aa3fbf5a7a41c6")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("16f9ec009e5568c435f473ba3a1df732d49ce8c3")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("1fd7d579fb6ae3fe942dc09c2c783443d04cf21e")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("20a8ade77639491ea0bd667bf95de8abf3a434c8")));
|
||||
assertTrue(pack.hasObject(ObjectId.fromString("2675188fd86978d5bc4d7211698b2118ae3bf658")));
|
||||
// and lots more...
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,8 +13,7 @@
|
|||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Thrown when a PackFile is found not to contain the pack signature defined by
|
||||
* git.
|
||||
* Thrown when a Pack is found not to contain the pack signature defined by git.
|
||||
*
|
||||
* @since 4.5
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
import org.eclipse.jgit.internal.JGitText;
|
||||
|
||||
/**
|
||||
* Thrown when a PackFile previously failed and is known to be unusable
|
||||
* Thrown when a Pack previously failed and is known to be unusable
|
||||
*/
|
||||
public class PackInvalidException extends IOException {
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Thrown when a PackFile no longer matches the PackIndex.
|
||||
* Thrown when a Pack no longer matches the PackIndex.
|
||||
*/
|
||||
public class PackMismatchException extends IOException {
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
import org.eclipse.jgit.internal.JGitText;
|
||||
|
||||
/**
|
||||
* Thrown when a PackFile uses a pack version not supported by JGit.
|
||||
* Thrown when a Pack uses a pack version not supported by JGit.
|
||||
*
|
||||
* @since 4.5
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@
|
|||
final class ByteArrayWindow extends ByteWindow {
|
||||
private final byte[] array;
|
||||
|
||||
ByteArrayWindow(PackFile pack, long o, byte[] b) {
|
||||
ByteArrayWindow(Pack pack, long o, byte[] b) {
|
||||
super(pack, o, b.length);
|
||||
array = b;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
final class ByteBufferWindow extends ByteWindow {
|
||||
private final ByteBuffer buffer;
|
||||
|
||||
ByteBufferWindow(PackFile pack, long o, ByteBuffer b) {
|
||||
ByteBufferWindow(Pack pack, long o, ByteBuffer b) {
|
||||
super(pack, o, b.capacity());
|
||||
buffer = b;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
* </p>
|
||||
*/
|
||||
abstract class ByteWindow {
|
||||
protected final PackFile pack;
|
||||
protected final Pack pack;
|
||||
|
||||
protected final long start;
|
||||
|
||||
|
|
@ -37,13 +37,13 @@ abstract class ByteWindow {
|
|||
* Constructor for ByteWindow.
|
||||
*
|
||||
* @param p
|
||||
* a {@link org.eclipse.jgit.internal.storage.file.PackFile}.
|
||||
* a {@link org.eclipse.jgit.internal.storage.file.Pack}.
|
||||
* @param s
|
||||
* where the byte window starts in the pack file
|
||||
* @param n
|
||||
* size of the byte window
|
||||
*/
|
||||
protected ByteWindow(PackFile p, long s, int n) {
|
||||
protected ByteWindow(Pack p, long s, int n) {
|
||||
pack = p;
|
||||
start = s;
|
||||
end = start + n;
|
||||
|
|
@ -53,8 +53,8 @@ final int size() {
|
|||
return (int) (end - start);
|
||||
}
|
||||
|
||||
final boolean contains(PackFile neededFile, long neededPos) {
|
||||
return pack == neededFile && start <= neededPos && neededPos < end;
|
||||
final boolean contains(Pack neededPack, long neededPos) {
|
||||
return pack == neededPack && start <= neededPos && neededPos < end;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -239,7 +239,7 @@ InsertLooseObjectResult insertUnpackedObject(File tmp, ObjectId objectId,
|
|||
}
|
||||
|
||||
@Override
|
||||
PackFile openPack(File pack) throws IOException {
|
||||
Pack openPack(File pack) throws IOException {
|
||||
return wrapped.openPack(pack);
|
||||
}
|
||||
|
||||
|
|
@ -250,7 +250,7 @@ void selectObjectRepresentation(PackWriter packer, ObjectToPack otp,
|
|||
}
|
||||
|
||||
@Override
|
||||
Collection<PackFile> getPacks() {
|
||||
Collection<Pack> getPacks() {
|
||||
return wrapped.getPacks();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ static void reconfigure(WindowCacheConfig cfg) {
|
|||
cache = new Slot[CACHE_SZ];
|
||||
}
|
||||
|
||||
Entry get(PackFile pack, long position) {
|
||||
Entry get(Pack pack, long position) {
|
||||
Slot e = cache[hash(position)];
|
||||
if (e == null)
|
||||
return null;
|
||||
|
|
@ -63,7 +63,7 @@ Entry get(PackFile pack, long position) {
|
|||
return null;
|
||||
}
|
||||
|
||||
void store(final PackFile pack, final long position,
|
||||
void store(final Pack pack, final long position,
|
||||
final byte[] data, final int objectType) {
|
||||
if (data.length > maxByteCount)
|
||||
return; // Too large to cache.
|
||||
|
|
@ -146,7 +146,7 @@ private static class Slot {
|
|||
|
||||
Slot lruNext;
|
||||
|
||||
PackFile provider;
|
||||
Pack provider;
|
||||
|
||||
long position;
|
||||
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ abstract ObjectLoader openLooseObject(WindowCursor curs, AnyObjectId id)
|
|||
abstract InsertLooseObjectResult insertUnpackedObject(File tmp,
|
||||
ObjectId id, boolean createDuplicate) throws IOException;
|
||||
|
||||
abstract PackFile openPack(File pack) throws IOException;
|
||||
abstract Pack openPack(File pack) throws IOException;
|
||||
|
||||
abstract Collection<PackFile> getPacks();
|
||||
abstract Collection<Pack> getPacks();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -205,16 +205,16 @@ public GC(FileRepository repo) {
|
|||
* gc.log.
|
||||
*
|
||||
* @return the collection of
|
||||
* {@link org.eclipse.jgit.internal.storage.file.PackFile}'s which
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}'s which
|
||||
* are newly created
|
||||
* @throws java.io.IOException
|
||||
* @throws java.text.ParseException
|
||||
* If the configuration parameter "gc.pruneexpire" couldn't be
|
||||
* parsed
|
||||
*/
|
||||
// TODO(ms): change signature and return Future<Collection<PackFile>>
|
||||
// TODO(ms): change signature and return Future<Collection<Pack>>
|
||||
@SuppressWarnings("FutureReturnValueIgnored")
|
||||
public Collection<PackFile> gc() throws IOException, ParseException {
|
||||
public Collection<Pack> gc() throws IOException, ParseException {
|
||||
if (!background) {
|
||||
return doGc();
|
||||
}
|
||||
|
|
@ -224,9 +224,9 @@ public Collection<PackFile> gc() throws IOException, ParseException {
|
|||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
Callable<Collection<PackFile>> gcTask = () -> {
|
||||
Callable<Collection<Pack>> gcTask = () -> {
|
||||
try {
|
||||
Collection<PackFile> newPacks = doGc();
|
||||
Collection<Pack> newPacks = doGc();
|
||||
if (automatic && tooManyLooseObjects()) {
|
||||
String message = JGitText.get().gcTooManyUnpruned;
|
||||
gcLog.write(message);
|
||||
|
|
@ -258,14 +258,14 @@ private ExecutorService executor() {
|
|||
return (executor != null) ? executor : WorkQueue.getExecutor();
|
||||
}
|
||||
|
||||
private Collection<PackFile> doGc() throws IOException, ParseException {
|
||||
private Collection<Pack> doGc() throws IOException, ParseException {
|
||||
if (automatic && !needGc()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
pm.start(6 /* tasks */);
|
||||
packRefs();
|
||||
// TODO: implement reflog_expire(pm, repo);
|
||||
Collection<PackFile> newPacks = repack();
|
||||
Collection<Pack> newPacks = repack();
|
||||
prune(Collections.emptySet());
|
||||
// TODO: implement rerere_gc(pm);
|
||||
return newPacks;
|
||||
|
|
@ -281,7 +281,7 @@ private Collection<PackFile> doGc() throws IOException, ParseException {
|
|||
* @param existing
|
||||
* @throws IOException
|
||||
*/
|
||||
private void loosen(ObjectDirectoryInserter inserter, ObjectReader reader, PackFile pack, HashSet<ObjectId> existing)
|
||||
private void loosen(ObjectDirectoryInserter inserter, ObjectReader reader, Pack pack, HashSet<ObjectId> existing)
|
||||
throws IOException {
|
||||
for (PackIndex.MutableEntry entry : pack) {
|
||||
ObjectId oid = entry.toObjectId();
|
||||
|
|
@ -313,10 +313,10 @@ private void loosen(ObjectDirectoryInserter inserter, ObjectReader reader, PackF
|
|||
* @throws ParseException
|
||||
* @throws IOException
|
||||
*/
|
||||
private void deleteOldPacks(Collection<PackFile> oldPacks,
|
||||
Collection<PackFile> newPacks) throws ParseException, IOException {
|
||||
private void deleteOldPacks(Collection<Pack> oldPacks,
|
||||
Collection<Pack> newPacks) throws ParseException, IOException {
|
||||
HashSet<ObjectId> ids = new HashSet<>();
|
||||
for (PackFile pack : newPacks) {
|
||||
for (Pack pack : newPacks) {
|
||||
for (PackIndex.MutableEntry entry : pack) {
|
||||
ids.add(entry.toObjectId());
|
||||
}
|
||||
|
|
@ -329,12 +329,12 @@ private void deleteOldPacks(Collection<PackFile> oldPacks,
|
|||
|
||||
prunePreserved();
|
||||
long packExpireDate = getPackExpireDate();
|
||||
oldPackLoop: for (PackFile oldPack : oldPacks) {
|
||||
oldPackLoop: for (Pack oldPack : oldPacks) {
|
||||
checkCancelled();
|
||||
String oldName = oldPack.getPackName();
|
||||
// check whether an old pack file is also among the list of new
|
||||
// pack files. Then we must not delete it.
|
||||
for (PackFile newPack : newPacks)
|
||||
for (Pack newPack : newPacks)
|
||||
if (oldName.equals(newPack.getPackName()))
|
||||
continue oldPackLoop;
|
||||
|
||||
|
|
@ -438,7 +438,7 @@ private void prunePack(String packName) {
|
|||
*/
|
||||
public void prunePacked() throws IOException {
|
||||
ObjectDirectory objdb = repo.getObjectDatabase();
|
||||
Collection<PackFile> packs = objdb.getPacks();
|
||||
Collection<Pack> packs = objdb.getPacks();
|
||||
File objects = repo.getObjectsDirectory();
|
||||
String[] fanout = objects.list();
|
||||
|
||||
|
|
@ -466,7 +466,7 @@ public void prunePacked() throws IOException {
|
|||
continue;
|
||||
}
|
||||
boolean found = false;
|
||||
for (PackFile p : packs) {
|
||||
for (Pack p : packs) {
|
||||
checkCancelled();
|
||||
if (p.hasObject(id)) {
|
||||
found = true;
|
||||
|
|
@ -788,8 +788,8 @@ public void packRefs() throws IOException {
|
|||
* reflog-entries or during writing to the packfiles
|
||||
* {@link java.io.IOException} occurs
|
||||
*/
|
||||
public Collection<PackFile> repack() throws IOException {
|
||||
Collection<PackFile> toBeDeleted = repo.getObjectDatabase().getPacks();
|
||||
public Collection<Pack> repack() throws IOException {
|
||||
Collection<Pack> toBeDeleted = repo.getObjectDatabase().getPacks();
|
||||
|
||||
long time = System.currentTimeMillis();
|
||||
Collection<Ref> refsBefore = getAllRefs();
|
||||
|
|
@ -821,10 +821,10 @@ public Collection<PackFile> repack() throws IOException {
|
|||
}
|
||||
|
||||
List<ObjectIdSet> excluded = new LinkedList<>();
|
||||
for (PackFile f : repo.getObjectDatabase().getPacks()) {
|
||||
for (Pack p : repo.getObjectDatabase().getPacks()) {
|
||||
checkCancelled();
|
||||
if (f.shouldBeKept())
|
||||
excluded.add(f.getIndex());
|
||||
if (p.shouldBeKept())
|
||||
excluded.add(p.getIndex());
|
||||
}
|
||||
|
||||
// Don't exclude tags that are also branch tips
|
||||
|
|
@ -842,8 +842,8 @@ public Collection<PackFile> repack() throws IOException {
|
|||
nonHeads.clear();
|
||||
}
|
||||
|
||||
List<PackFile> ret = new ArrayList<>(2);
|
||||
PackFile heads = null;
|
||||
List<Pack> ret = new ArrayList<>(2);
|
||||
Pack heads = null;
|
||||
if (!allHeadsAndTags.isEmpty()) {
|
||||
heads = writePack(allHeadsAndTags, PackWriter.NONE, allTags,
|
||||
tagTargets, excluded);
|
||||
|
|
@ -853,13 +853,13 @@ public Collection<PackFile> repack() throws IOException {
|
|||
}
|
||||
}
|
||||
if (!nonHeads.isEmpty()) {
|
||||
PackFile rest = writePack(nonHeads, allHeadsAndTags, PackWriter.NONE,
|
||||
Pack rest = writePack(nonHeads, allHeadsAndTags, PackWriter.NONE,
|
||||
tagTargets, excluded);
|
||||
if (rest != null)
|
||||
ret.add(rest);
|
||||
}
|
||||
if (!txnHeads.isEmpty()) {
|
||||
PackFile txn = writePack(txnHeads, PackWriter.NONE, PackWriter.NONE,
|
||||
Pack txn = writePack(txnHeads, PackWriter.NONE, PackWriter.NONE,
|
||||
null, excluded);
|
||||
if (txn != null)
|
||||
ret.add(txn);
|
||||
|
|
@ -1129,7 +1129,7 @@ private Set<ObjectId> listNonHEADIndexObjects()
|
|||
}
|
||||
}
|
||||
|
||||
private PackFile writePack(@NonNull Set<? extends ObjectId> want,
|
||||
private Pack writePack(@NonNull Set<? extends ObjectId> want,
|
||||
@NonNull Set<? extends ObjectId> have, @NonNull Set<ObjectId> tags,
|
||||
Set<ObjectId> tagTargets, List<ObjectIdSet> excludeObjects)
|
||||
throws IOException {
|
||||
|
|
@ -1356,13 +1356,13 @@ public String toString() {
|
|||
*/
|
||||
public RepoStatistics getStatistics() throws IOException {
|
||||
RepoStatistics ret = new RepoStatistics();
|
||||
Collection<PackFile> packs = repo.getObjectDatabase().getPacks();
|
||||
for (PackFile f : packs) {
|
||||
ret.numberOfPackedObjects += f.getIndex().getObjectCount();
|
||||
Collection<Pack> packs = repo.getObjectDatabase().getPacks();
|
||||
for (Pack p : packs) {
|
||||
ret.numberOfPackedObjects += p.getIndex().getObjectCount();
|
||||
ret.numberOfPackFiles++;
|
||||
ret.sizeOfPackedObjects += f.getPackFile().length();
|
||||
if (f.getBitmapIndex() != null)
|
||||
ret.numberOfBitmaps += f.getBitmapIndex().getBitmapCount();
|
||||
ret.sizeOfPackedObjects += p.getPackFile().length();
|
||||
if (p.getBitmapIndex() != null)
|
||||
ret.numberOfBitmaps += p.getBitmapIndex().getBitmapCount();
|
||||
}
|
||||
File objDir = repo.getObjectsDirectory();
|
||||
String[] fanout = objDir.list();
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@ class LargePackedWholeObject extends ObjectLoader {
|
|||
|
||||
private final int headerLength;
|
||||
|
||||
private final PackFile pack;
|
||||
private final Pack pack;
|
||||
|
||||
private final FileObjectDatabase db;
|
||||
|
||||
LargePackedWholeObject(int type, long size, long objectOffset,
|
||||
int headerLength, PackFile pack, FileObjectDatabase db) {
|
||||
int headerLength, Pack pack, FileObjectDatabase db) {
|
||||
this.type = type;
|
||||
this.size = size;
|
||||
this.objectOffset = objectOffset;
|
||||
|
|
|
|||
|
|
@ -25,31 +25,31 @@ class LocalCachedPack extends CachedPack {
|
|||
|
||||
private final String[] packNames;
|
||||
|
||||
private PackFile[] packs;
|
||||
private Pack[] packs;
|
||||
|
||||
LocalCachedPack(ObjectDirectory odb, List<String> packNames) {
|
||||
this.odb = odb;
|
||||
this.packNames = packNames.toArray(new String[0]);
|
||||
}
|
||||
|
||||
LocalCachedPack(List<PackFile> packs) {
|
||||
LocalCachedPack(List<Pack> packs) {
|
||||
odb = null;
|
||||
packNames = null;
|
||||
this.packs = packs.toArray(new PackFile[0]);
|
||||
this.packs = packs.toArray(new Pack[0]);
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public long getObjectCount() throws IOException {
|
||||
long cnt = 0;
|
||||
for (PackFile pack : getPacks())
|
||||
for (Pack pack : getPacks())
|
||||
cnt += pack.getObjectCount();
|
||||
return cnt;
|
||||
}
|
||||
|
||||
void copyAsIs(PackOutputStream out, WindowCursor wc)
|
||||
throws IOException {
|
||||
for (PackFile pack : getPacks())
|
||||
for (Pack pack : getPacks())
|
||||
pack.copyPackAsIs(out, wc);
|
||||
}
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ void copyAsIs(PackOutputStream out, WindowCursor wc)
|
|||
public boolean hasObject(ObjectToPack obj, StoredObjectRepresentation rep) {
|
||||
try {
|
||||
LocalObjectRepresentation local = (LocalObjectRepresentation) rep;
|
||||
for (PackFile pack : getPacks()) {
|
||||
for (Pack pack : getPacks()) {
|
||||
if (local.pack == pack)
|
||||
return true;
|
||||
}
|
||||
|
|
@ -68,9 +68,9 @@ public boolean hasObject(ObjectToPack obj, StoredObjectRepresentation rep) {
|
|||
}
|
||||
}
|
||||
|
||||
private PackFile[] getPacks() throws FileNotFoundException {
|
||||
private Pack[] getPacks() throws FileNotFoundException {
|
||||
if (packs == null) {
|
||||
PackFile[] p = new PackFile[packNames.length];
|
||||
Pack[] p = new Pack[packNames.length];
|
||||
for (int i = 0; i < packNames.length; i++)
|
||||
p[i] = getPackFile(packNames[i]);
|
||||
packs = p;
|
||||
|
|
@ -78,8 +78,8 @@ private PackFile[] getPacks() throws FileNotFoundException {
|
|||
return packs;
|
||||
}
|
||||
|
||||
private PackFile getPackFile(String packName) throws FileNotFoundException {
|
||||
for (PackFile pack : odb.getPacks()) {
|
||||
private Pack getPackFile(String packName) throws FileNotFoundException {
|
||||
for (Pack pack : odb.getPacks()) {
|
||||
if (packName.equals(pack.getPackName()))
|
||||
return pack;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,40 +16,40 @@
|
|||
import org.eclipse.jgit.lib.ObjectId;
|
||||
|
||||
class LocalObjectRepresentation extends StoredObjectRepresentation {
|
||||
static LocalObjectRepresentation newWhole(PackFile f, long p, long length) {
|
||||
static LocalObjectRepresentation newWhole(Pack pack, long offset, long length) {
|
||||
LocalObjectRepresentation r = new LocalObjectRepresentation() {
|
||||
@Override
|
||||
public int getFormat() {
|
||||
return PACK_WHOLE;
|
||||
}
|
||||
};
|
||||
r.pack = f;
|
||||
r.offset = p;
|
||||
r.pack = pack;
|
||||
r.offset = offset;
|
||||
r.length = length;
|
||||
return r;
|
||||
}
|
||||
|
||||
static LocalObjectRepresentation newDelta(PackFile f, long p, long n,
|
||||
static LocalObjectRepresentation newDelta(Pack pack, long offset, long length,
|
||||
ObjectId base) {
|
||||
LocalObjectRepresentation r = new Delta();
|
||||
r.pack = f;
|
||||
r.offset = p;
|
||||
r.length = n;
|
||||
r.pack = pack;
|
||||
r.offset = offset;
|
||||
r.length = length;
|
||||
r.baseId = base;
|
||||
return r;
|
||||
}
|
||||
|
||||
static LocalObjectRepresentation newDelta(PackFile f, long p, long n,
|
||||
static LocalObjectRepresentation newDelta(Pack pack, long offset, long length,
|
||||
long base) {
|
||||
LocalObjectRepresentation r = new Delta();
|
||||
r.pack = f;
|
||||
r.offset = p;
|
||||
r.length = n;
|
||||
r.pack = pack;
|
||||
r.offset = offset;
|
||||
r.length = length;
|
||||
r.baseOffset = base;
|
||||
return r;
|
||||
}
|
||||
|
||||
PackFile pack;
|
||||
Pack pack;
|
||||
|
||||
long offset;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
/** {@link ObjectToPack} for {@link ObjectDirectory}. */
|
||||
class LocalObjectToPack extends ObjectToPack {
|
||||
/** Pack to reuse compressed data from, otherwise null. */
|
||||
PackFile pack;
|
||||
Pack pack;
|
||||
|
||||
/** Offset of the object's header in {@link #pack}. */
|
||||
long offset;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@
|
|||
* This is the classical object database representation for a Git repository,
|
||||
* where objects are stored loose by hashing them into directories by their
|
||||
* {@link org.eclipse.jgit.lib.ObjectId}, or are stored in compressed containers
|
||||
* known as {@link org.eclipse.jgit.internal.storage.file.PackFile}s.
|
||||
* known as {@link org.eclipse.jgit.internal.storage.file.Pack}s.
|
||||
* <p>
|
||||
* Optionally an object database can reference one or more alternates; other
|
||||
* ObjectDatabase instances that are searched in addition to the current
|
||||
|
|
@ -206,7 +206,7 @@ public void close() {
|
|||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public Collection<PackFile> getPacks() {
|
||||
public Collection<Pack> getPacks() {
|
||||
return packed.getPacks();
|
||||
}
|
||||
|
||||
|
|
@ -216,7 +216,7 @@ public Collection<PackFile> getPacks() {
|
|||
* Add a single existing pack to the list of available pack files.
|
||||
*/
|
||||
@Override
|
||||
public PackFile openPack(File pack)
|
||||
public Pack openPack(File pack)
|
||||
throws IOException {
|
||||
final String p = pack.getName();
|
||||
if (p.length() != 50 || !p.startsWith("pack-") || !p.endsWith(".pack")) //$NON-NLS-1$ //$NON-NLS-2$
|
||||
|
|
@ -235,7 +235,7 @@ public PackFile openPack(File pack)
|
|||
}
|
||||
}
|
||||
|
||||
PackFile res = new PackFile(pack, extensions);
|
||||
Pack res = new Pack(pack, extensions);
|
||||
packed.insert(res);
|
||||
return res;
|
||||
}
|
||||
|
|
@ -509,7 +509,7 @@ void closeAllPackHandles(File packFile) {
|
|||
// PackConfig) then make sure we get rid of all handles on the file.
|
||||
// Windows will not allow for rename otherwise.
|
||||
if (packFile.exists()) {
|
||||
for (PackFile p : packed.getPacks()) {
|
||||
for (Pack p : packed.getPacks()) {
|
||||
if (packFile.getPath().equals(p.getPackFile().getPath())) {
|
||||
p.close();
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ public class ObjectDirectoryPackParser extends PackParser {
|
|||
private Deflater def;
|
||||
|
||||
/** The pack that was created, if parsing was successful. */
|
||||
private PackFile newPack;
|
||||
private Pack newPack;
|
||||
|
||||
private PackConfig pconfig;
|
||||
|
||||
|
|
@ -129,14 +129,14 @@ public void setKeepEmpty(boolean empty) {
|
|||
}
|
||||
|
||||
/**
|
||||
* Get the imported {@link org.eclipse.jgit.internal.storage.file.PackFile}.
|
||||
* Get the imported {@link org.eclipse.jgit.internal.storage.file.Pack}.
|
||||
* <p>
|
||||
* This method is supplied only to support testing; applications shouldn't
|
||||
* be using it directly to access the imported data.
|
||||
*
|
||||
* @return the imported PackFile, if parsing was successful.
|
||||
*/
|
||||
public PackFile getPackFile() {
|
||||
public Pack getPack() {
|
||||
return newPack;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -69,13 +69,13 @@
|
|||
* delta packed format yielding high compression of lots of object where some
|
||||
* objects are similar.
|
||||
*/
|
||||
public class PackFile implements Iterable<PackIndex.MutableEntry> {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(PackFile.class);
|
||||
public class Pack implements Iterable<PackIndex.MutableEntry> {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(Pack.class);
|
||||
|
||||
/**
|
||||
* Sorts PackFiles to be most recently created to least recently created.
|
||||
*/
|
||||
public static final Comparator<PackFile> SORT = (a, b) -> b.packLastModified
|
||||
public static final Comparator<Pack> SORT = (a, b) -> b.packLastModified
|
||||
.compareTo(a.packLastModified);
|
||||
|
||||
private final File packFile;
|
||||
|
|
@ -136,7 +136,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> {
|
|||
* @param extensions
|
||||
* additional pack file extensions with the same base as the pack
|
||||
*/
|
||||
public PackFile(File packFile, int extensions) {
|
||||
public Pack(File packFile, int extensions) {
|
||||
this.packFile = packFile;
|
||||
this.fileSnapshot = PackFileSnapshot.save(packFile);
|
||||
this.packLastModified = fileSnapshot.lastModifiedInstant();
|
||||
|
|
@ -1201,7 +1201,7 @@ private boolean hasExt(PackExt ext) {
|
|||
@SuppressWarnings("nls")
|
||||
@Override
|
||||
public String toString() {
|
||||
return "PackFile [packFileName=" + packFile.getName() + ", length="
|
||||
return "Pack [packFileName=" + packFile.getName() + ", length="
|
||||
+ packFile.length() + ", packChecksum="
|
||||
+ ObjectId.fromRaw(packChecksum).name() + "]";
|
||||
}
|
||||
|
|
@ -47,16 +47,17 @@
|
|||
/**
|
||||
* Traditional file system packed objects directory handler.
|
||||
* <p>
|
||||
* This is the {@code PackFile}s object representation for a Git object
|
||||
* database, where objects are stored in compressed containers known as
|
||||
* {@link org.eclipse.jgit.internal.storage.file.PackFile}s.
|
||||
* This is the {@link org.eclipse.jgit.internal.storage.file.Pack}s object
|
||||
* representation for a Git object database, where objects are stored in
|
||||
* compressed containers known as
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}s.
|
||||
*/
|
||||
class PackDirectory {
|
||||
private final static Logger LOG = LoggerFactory
|
||||
.getLogger(PackDirectory.class);
|
||||
|
||||
private static final PackList NO_PACKS = new PackList(FileSnapshot.DIRTY,
|
||||
new PackFile[0]);
|
||||
new Pack[0]);
|
||||
|
||||
private final Config config;
|
||||
|
||||
|
|
@ -94,18 +95,18 @@ void create() throws IOException {
|
|||
void close() {
|
||||
PackList packs = packList.get();
|
||||
if (packs != NO_PACKS && packList.compareAndSet(packs, NO_PACKS)) {
|
||||
for (PackFile p : packs.packs) {
|
||||
for (Pack p : packs.packs) {
|
||||
p.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Collection<PackFile> getPacks() {
|
||||
Collection<Pack> getPacks() {
|
||||
PackList list = packList.get();
|
||||
if (list == NO_PACKS) {
|
||||
list = scanPacks(list);
|
||||
}
|
||||
PackFile[] packs = list.packs;
|
||||
Pack[] packs = list.packs;
|
||||
return Collections.unmodifiableCollection(Arrays.asList(packs));
|
||||
}
|
||||
|
||||
|
|
@ -126,7 +127,7 @@ boolean has(AnyObjectId objectId) {
|
|||
PackList pList;
|
||||
do {
|
||||
pList = packList.get();
|
||||
for (PackFile p : pList.packs) {
|
||||
for (Pack p : pList.packs) {
|
||||
try {
|
||||
if (p.hasObject(objectId)) {
|
||||
return true;
|
||||
|
|
@ -167,7 +168,7 @@ boolean resolve(Set<ObjectId> matches, AbbreviatedObjectId id,
|
|||
PackList pList;
|
||||
do {
|
||||
pList = packList.get();
|
||||
for (PackFile p : pList.packs) {
|
||||
for (Pack p : pList.packs) {
|
||||
try {
|
||||
p.resolve(matches, id, matchLimit);
|
||||
p.resetTransientErrorCount();
|
||||
|
|
@ -187,7 +188,7 @@ ObjectLoader open(WindowCursor curs, AnyObjectId objectId) {
|
|||
do {
|
||||
SEARCH: for (;;) {
|
||||
pList = packList.get();
|
||||
for (PackFile p : pList.packs) {
|
||||
for (Pack p : pList.packs) {
|
||||
try {
|
||||
ObjectLoader ldr = p.get(curs, objectId);
|
||||
p.resetTransientErrorCount();
|
||||
|
|
@ -213,7 +214,7 @@ long getSize(WindowCursor curs, AnyObjectId id) {
|
|||
do {
|
||||
SEARCH: for (;;) {
|
||||
pList = packList.get();
|
||||
for (PackFile p : pList.packs) {
|
||||
for (Pack p : pList.packs) {
|
||||
try {
|
||||
long len = p.getObjectSize(curs, id);
|
||||
p.resetTransientErrorCount();
|
||||
|
|
@ -239,7 +240,7 @@ void selectRepresentation(PackWriter packer, ObjectToPack otp,
|
|||
WindowCursor curs) {
|
||||
PackList pList = packList.get();
|
||||
SEARCH: for (;;) {
|
||||
for (PackFile p : pList.packs) {
|
||||
for (Pack p : pList.packs) {
|
||||
try {
|
||||
LocalObjectRepresentation rep = p.representation(curs, otp);
|
||||
p.resetTransientErrorCount();
|
||||
|
|
@ -259,7 +260,7 @@ void selectRepresentation(PackWriter packer, ObjectToPack otp,
|
|||
}
|
||||
}
|
||||
|
||||
private void handlePackError(IOException e, PackFile p) {
|
||||
private void handlePackError(IOException e, Pack p) {
|
||||
String warnTmpl = null;
|
||||
int transientErrorCount = 0;
|
||||
String errTmpl = JGitText.get().exceptionWhileReadingPack;
|
||||
|
|
@ -322,7 +323,7 @@ boolean searchPacksAgain(PackList old) {
|
|||
&& old != scanPacks(old);
|
||||
}
|
||||
|
||||
void insert(PackFile pf) {
|
||||
void insert(Pack pack) {
|
||||
PackList o, n;
|
||||
do {
|
||||
o = packList.get();
|
||||
|
|
@ -331,33 +332,33 @@ void insert(PackFile pf) {
|
|||
// (picked up by a concurrent thread that did a scan?) we
|
||||
// do not want to insert it a second time.
|
||||
//
|
||||
final PackFile[] oldList = o.packs;
|
||||
final String name = pf.getPackFile().getName();
|
||||
for (PackFile p : oldList) {
|
||||
final Pack[] oldList = o.packs;
|
||||
final String name = pack.getPackFile().getName();
|
||||
for (Pack p : oldList) {
|
||||
if (name.equals(p.getPackFile().getName())) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
final PackFile[] newList = new PackFile[1 + oldList.length];
|
||||
newList[0] = pf;
|
||||
final Pack[] newList = new Pack[1 + oldList.length];
|
||||
newList[0] = pack;
|
||||
System.arraycopy(oldList, 0, newList, 1, oldList.length);
|
||||
n = new PackList(o.snapshot, newList);
|
||||
} while (!packList.compareAndSet(o, n));
|
||||
}
|
||||
|
||||
private void remove(PackFile deadPack) {
|
||||
private void remove(Pack deadPack) {
|
||||
PackList o, n;
|
||||
do {
|
||||
o = packList.get();
|
||||
|
||||
final PackFile[] oldList = o.packs;
|
||||
final Pack[] oldList = o.packs;
|
||||
final int j = indexOf(oldList, deadPack);
|
||||
if (j < 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
final PackFile[] newList = new PackFile[oldList.length - 1];
|
||||
final Pack[] newList = new Pack[oldList.length - 1];
|
||||
System.arraycopy(oldList, 0, newList, 0, j);
|
||||
System.arraycopy(oldList, j + 1, newList, j, newList.length - j);
|
||||
n = new PackList(o.snapshot, newList);
|
||||
|
|
@ -365,7 +366,7 @@ private void remove(PackFile deadPack) {
|
|||
deadPack.close();
|
||||
}
|
||||
|
||||
private static int indexOf(PackFile[] list, PackFile pack) {
|
||||
private static int indexOf(Pack[] list, Pack pack) {
|
||||
for (int i = 0; i < list.length; i++) {
|
||||
if (list[i] == pack) {
|
||||
return i;
|
||||
|
|
@ -395,10 +396,10 @@ private PackList scanPacks(PackList original) {
|
|||
}
|
||||
|
||||
private PackList scanPacksImpl(PackList old) {
|
||||
final Map<String, PackFile> forReuse = reuseMap(old);
|
||||
final Map<String, Pack> forReuse = reuseMap(old);
|
||||
final FileSnapshot snapshot = FileSnapshot.save(directory);
|
||||
final Set<String> names = listPackDirectory();
|
||||
final List<PackFile> list = new ArrayList<>(names.size() >> 2);
|
||||
final List<Pack> list = new ArrayList<>(names.size() >> 2);
|
||||
boolean foundNew = false;
|
||||
for (String indexName : names) {
|
||||
// Must match "pack-[0-9a-f]{40}.idx" to be an index.
|
||||
|
|
@ -425,7 +426,7 @@ private PackList scanPacksImpl(PackList old) {
|
|||
|
||||
final String packName = base + PACK.getExtension();
|
||||
final File packFile = new File(directory, packName);
|
||||
final PackFile oldPack = forReuse.get(packName);
|
||||
final Pack oldPack = forReuse.get(packName);
|
||||
if (oldPack != null
|
||||
&& !oldPack.getFileSnapshot().isModified(packFile)) {
|
||||
forReuse.remove(packName);
|
||||
|
|
@ -433,7 +434,7 @@ private PackList scanPacksImpl(PackList old) {
|
|||
continue;
|
||||
}
|
||||
|
||||
list.add(new PackFile(packFile, extensions));
|
||||
list.add(new Pack(packFile, extensions));
|
||||
foundNew = true;
|
||||
}
|
||||
|
||||
|
|
@ -447,7 +448,7 @@ private PackList scanPacksImpl(PackList old) {
|
|||
return old;
|
||||
}
|
||||
|
||||
for (PackFile p : forReuse.values()) {
|
||||
for (Pack p : forReuse.values()) {
|
||||
p.close();
|
||||
}
|
||||
|
||||
|
|
@ -455,14 +456,14 @@ private PackList scanPacksImpl(PackList old) {
|
|||
return new PackList(snapshot, NO_PACKS.packs);
|
||||
}
|
||||
|
||||
final PackFile[] r = list.toArray(new PackFile[0]);
|
||||
Arrays.sort(r, PackFile.SORT);
|
||||
final Pack[] r = list.toArray(new Pack[0]);
|
||||
Arrays.sort(r, Pack.SORT);
|
||||
return new PackList(snapshot, r);
|
||||
}
|
||||
|
||||
private static Map<String, PackFile> reuseMap(PackList old) {
|
||||
final Map<String, PackFile> forReuse = new HashMap<>();
|
||||
for (PackFile p : old.packs) {
|
||||
private static Map<String, Pack> reuseMap(PackList old) {
|
||||
final Map<String, Pack> forReuse = new HashMap<>();
|
||||
for (Pack p : old.packs) {
|
||||
if (p.invalid()) {
|
||||
// The pack instance is corrupted, and cannot be safely used
|
||||
// again. Do not include it in our reuse map.
|
||||
|
|
@ -471,7 +472,7 @@ private static Map<String, PackFile> reuseMap(PackList old) {
|
|||
continue;
|
||||
}
|
||||
|
||||
final PackFile prior = forReuse.put(p.getPackFile().getName(), p);
|
||||
final Pack prior = forReuse.put(p.getPackFile().getName(), p);
|
||||
if (prior != null) {
|
||||
// This should never occur. It should be impossible for us
|
||||
// to have two pack files with the same name, as all of them
|
||||
|
|
@ -504,10 +505,10 @@ static final class PackList {
|
|||
/** State just before reading the pack directory. */
|
||||
final FileSnapshot snapshot;
|
||||
|
||||
/** All known packs, sorted by {@link PackFile#SORT}. */
|
||||
final PackFile[] packs;
|
||||
/** All known packs, sorted by {@link Pack#SORT}. */
|
||||
final Pack[] packs;
|
||||
|
||||
PackList(FileSnapshot monitor, PackFile[] packs) {
|
||||
PackList(FileSnapshot monitor, Pack[] packs) {
|
||||
this.snapshot = monitor;
|
||||
this.packs = packs;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
|
||||
/**
|
||||
* Access path to locate objects by {@link org.eclipse.jgit.lib.ObjectId} in a
|
||||
* {@link org.eclipse.jgit.internal.storage.file.PackFile}.
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}.
|
||||
* <p>
|
||||
* Indexes are strictly redundant information in that we can rebuild all of the
|
||||
* data held in the index file from the on disk representation of the pack file
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
/**
|
||||
* Creates a table of contents to support random access by
|
||||
* {@link org.eclipse.jgit.internal.storage.file.PackFile}.
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}.
|
||||
* <p>
|
||||
* Pack index files (the <code>.idx</code> suffix in a pack file pair) provides
|
||||
* random access to any object in the pack by associating an ObjectId to the
|
||||
|
|
|
|||
|
|
@ -16,11 +16,11 @@
|
|||
class PackInputStream extends InputStream {
|
||||
private final WindowCursor wc;
|
||||
|
||||
private final PackFile pack;
|
||||
private final Pack pack;
|
||||
|
||||
private long pos;
|
||||
|
||||
PackInputStream(PackFile pack, long pos, WindowCursor wc)
|
||||
PackInputStream(Pack pack, long pos, WindowCursor wc)
|
||||
throws IOException {
|
||||
this.pack = pack;
|
||||
this.pos = pos;
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
import org.eclipse.jgit.util.FileUtils;
|
||||
|
||||
/**
|
||||
* Keeps track of a {@link org.eclipse.jgit.internal.storage.file.PackFile}'s
|
||||
* Keeps track of a {@link org.eclipse.jgit.internal.storage.file.Pack}'s
|
||||
* associated <code>.keep</code> file.
|
||||
*/
|
||||
public class PackLock {
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@
|
|||
* </p>
|
||||
*
|
||||
* @see PackIndex
|
||||
* @see PackFile
|
||||
* @see Pack
|
||||
*/
|
||||
public class PackReverseIndex {
|
||||
/** Index we were created from, and that has our ObjectId data. */
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
import org.eclipse.jgit.util.Monitoring;
|
||||
|
||||
/**
|
||||
* Caches slices of a {@link org.eclipse.jgit.internal.storage.file.PackFile} in
|
||||
* Caches slices of a {@link org.eclipse.jgit.internal.storage.file.Pack} in
|
||||
* memory for faster read access.
|
||||
* <p>
|
||||
* The WindowCache serves as a Java based "buffer cache", loading segments of a
|
||||
|
|
@ -41,7 +41,7 @@
|
|||
* only tiny slices of a file, the WindowCache tries to smooth out these tiny
|
||||
* reads into larger block-sized IO operations.
|
||||
* <p>
|
||||
* Whenever a cache miss occurs, {@link #load(PackFile, long)} is invoked by
|
||||
* Whenever a cache miss occurs, {@link #load(Pack, long)} is invoked by
|
||||
* exactly one thread for the given <code>(PackFile,position)</code> key tuple.
|
||||
* This is ensured by an array of locks, with the tuple hashed to a lock
|
||||
* instance.
|
||||
|
|
@ -80,10 +80,10 @@
|
|||
* <p>
|
||||
* This cache has an implementation rule such that:
|
||||
* <ul>
|
||||
* <li>{@link #load(PackFile, long)} is invoked by at most one thread at a time
|
||||
* <li>{@link #load(Pack, long)} is invoked by at most one thread at a time
|
||||
* for a given <code>(PackFile,position)</code> tuple.</li>
|
||||
* <li>For every <code>load()</code> invocation there is exactly one
|
||||
* {@link #createRef(PackFile, long, ByteWindow)} invocation to wrap a
|
||||
* {@link #createRef(Pack, long, ByteWindow)} invocation to wrap a
|
||||
* SoftReference or a StrongReference around the cached entity.</li>
|
||||
* <li>For every Reference created by <code>createRef()</code> there will be
|
||||
* exactly one call to {@link #clear(PageRef)} to cleanup any resources associated
|
||||
|
|
@ -91,10 +91,10 @@
|
|||
* </ul>
|
||||
* <p>
|
||||
* Therefore, it is safe to perform resource accounting increments during the
|
||||
* {@link #load(PackFile, long)} or
|
||||
* {@link #createRef(PackFile, long, ByteWindow)} methods, and matching
|
||||
* {@link #load(Pack, long)} or
|
||||
* {@link #createRef(Pack, long, ByteWindow)} methods, and matching
|
||||
* decrements during {@link #clear(PageRef)}. Implementors may need to override
|
||||
* {@link #createRef(PackFile, long, ByteWindow)} in order to embed additional
|
||||
* {@link #createRef(Pack, long, ByteWindow)} in order to embed additional
|
||||
* accounting information into an implementation specific
|
||||
* {@link org.eclipse.jgit.internal.storage.file.WindowCache.PageRef} subclass, as
|
||||
* the cached entity may have already been evicted by the JRE's garbage
|
||||
|
|
@ -170,7 +170,7 @@ static interface StatsRecorder {
|
|||
* @param delta
|
||||
* delta of cached bytes
|
||||
*/
|
||||
void recordOpenBytes(PackFile pack, int delta);
|
||||
void recordOpenBytes(Pack pack, int delta);
|
||||
|
||||
/**
|
||||
* Returns a snapshot of this recorder's stats. Note that this may be an
|
||||
|
|
@ -242,7 +242,7 @@ public void recordOpenFiles(int delta) {
|
|||
}
|
||||
|
||||
@Override
|
||||
public void recordOpenBytes(PackFile pack, int delta) {
|
||||
public void recordOpenBytes(Pack pack, int delta) {
|
||||
openByteCount.add(delta);
|
||||
String repositoryId = repositoryId(pack);
|
||||
LongAdder la = openByteCountPerRepository
|
||||
|
|
@ -254,9 +254,8 @@ public void recordOpenBytes(PackFile pack, int delta) {
|
|||
}
|
||||
}
|
||||
|
||||
private static String repositoryId(PackFile pack) {
|
||||
// use repository's gitdir since packfile doesn't know its
|
||||
// repository
|
||||
private static String repositoryId(Pack pack) {
|
||||
// use repository's gitdir since Pack doesn't know its repository
|
||||
return pack.getPackFile().getParentFile().getParentFile()
|
||||
.getParent();
|
||||
}
|
||||
|
|
@ -380,7 +379,7 @@ public static WindowCache getInstance() {
|
|||
return cache.publishMBeanIfNeeded();
|
||||
}
|
||||
|
||||
static final ByteWindow get(PackFile pack, long offset)
|
||||
static final ByteWindow get(Pack pack, long offset)
|
||||
throws IOException {
|
||||
final WindowCache c = cache;
|
||||
final ByteWindow r = c.getOrLoad(pack, c.toStart(offset));
|
||||
|
|
@ -395,7 +394,7 @@ static final ByteWindow get(PackFile pack, long offset)
|
|||
return r;
|
||||
}
|
||||
|
||||
static final void purge(PackFile pack) {
|
||||
static final void purge(Pack pack) {
|
||||
cache.removeAll(pack);
|
||||
}
|
||||
|
||||
|
|
@ -506,7 +505,7 @@ private int hash(int packHash, long off) {
|
|||
return packHash + (int) (off >>> windowSizeShift);
|
||||
}
|
||||
|
||||
private ByteWindow load(PackFile pack, long offset) throws IOException {
|
||||
private ByteWindow load(Pack pack, long offset) throws IOException {
|
||||
long startTime = System.nanoTime();
|
||||
if (pack.beginWindowCache())
|
||||
statsRecorder.recordOpenFiles(1);
|
||||
|
|
@ -525,7 +524,7 @@ private ByteWindow load(PackFile pack, long offset) throws IOException {
|
|||
}
|
||||
}
|
||||
|
||||
private PageRef<ByteWindow> createRef(PackFile p, long o, ByteWindow v) {
|
||||
private PageRef<ByteWindow> createRef(Pack p, long o, ByteWindow v) {
|
||||
final PageRef<ByteWindow> ref = useStrongRefs
|
||||
? new StrongRef(p, o, v, queue)
|
||||
: new SoftRef(p, o, v, (SoftCleanupQueue) queue);
|
||||
|
|
@ -539,7 +538,7 @@ private void clear(PageRef<ByteWindow> ref) {
|
|||
close(ref.getPack());
|
||||
}
|
||||
|
||||
private void close(PackFile pack) {
|
||||
private void close(Pack pack) {
|
||||
if (pack.endWindowCache()) {
|
||||
statsRecorder.recordOpenFiles(-1);
|
||||
}
|
||||
|
|
@ -578,9 +577,9 @@ private static int lockCount(WindowCacheConfig cfg) {
|
|||
* @return the object reference.
|
||||
* @throws IOException
|
||||
* the object reference was not in the cache and could not be
|
||||
* obtained by {@link #load(PackFile, long)}.
|
||||
* obtained by {@link #load(Pack, long)}.
|
||||
*/
|
||||
private ByteWindow getOrLoad(PackFile pack, long position)
|
||||
private ByteWindow getOrLoad(Pack pack, long position)
|
||||
throws IOException {
|
||||
final int slot = slot(pack, position);
|
||||
final Entry e1 = table.get(slot);
|
||||
|
|
@ -623,7 +622,7 @@ private ByteWindow getOrLoad(PackFile pack, long position)
|
|||
return v;
|
||||
}
|
||||
|
||||
private ByteWindow scan(Entry n, PackFile pack, long position) {
|
||||
private ByteWindow scan(Entry n, Pack pack, long position) {
|
||||
for (; n != null; n = n.next) {
|
||||
final PageRef<ByteWindow> r = n.ref;
|
||||
if (r.getPack() == pack && r.getPosition() == position) {
|
||||
|
|
@ -704,7 +703,7 @@ private void removeAll() {
|
|||
/**
|
||||
* Clear all entries related to a single file.
|
||||
* <p>
|
||||
* Typically this method is invoked during {@link PackFile#close()}, when we
|
||||
* Typically this method is invoked during {@link Pack#close()}, when we
|
||||
* know the pack is never going to be useful to us again (for example, it no
|
||||
* longer exists on disk). A concurrent reader loading an entry from this
|
||||
* same pack may cause the pack to become stuck in the cache anyway.
|
||||
|
|
@ -712,7 +711,7 @@ private void removeAll() {
|
|||
* @param pack
|
||||
* the file to purge all entries of.
|
||||
*/
|
||||
private void removeAll(PackFile pack) {
|
||||
private void removeAll(Pack pack) {
|
||||
for (int s = 0; s < tableSize; s++) {
|
||||
final Entry e1 = table.get(s);
|
||||
boolean hasDead = false;
|
||||
|
|
@ -733,11 +732,11 @@ private void gc() {
|
|||
queue.gc();
|
||||
}
|
||||
|
||||
private int slot(PackFile pack, long position) {
|
||||
private int slot(Pack pack, long position) {
|
||||
return (hash(pack.hash, position) >>> 1) % tableSize;
|
||||
}
|
||||
|
||||
private Lock lock(PackFile pack, long position) {
|
||||
private Lock lock(Pack pack, long position) {
|
||||
return locks[(hash(pack.hash, position) >>> 1) % locks.length];
|
||||
}
|
||||
|
||||
|
|
@ -799,16 +798,20 @@ private static interface PageRef<T> {
|
|||
boolean kill();
|
||||
|
||||
/**
|
||||
* Get the packfile the referenced cache page is allocated for
|
||||
* Get the {@link org.eclipse.jgit.internal.storage.file.Pack} the
|
||||
* referenced cache page is allocated for
|
||||
*
|
||||
* @return the packfile the referenced cache page is allocated for
|
||||
* @return the {@link org.eclipse.jgit.internal.storage.file.Pack} the
|
||||
* referenced cache page is allocated for
|
||||
*/
|
||||
PackFile getPack();
|
||||
Pack getPack();
|
||||
|
||||
/**
|
||||
* Get the position of the referenced cache page in the packfile
|
||||
* Get the position of the referenced cache page in the
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}
|
||||
*
|
||||
* @return the position of the referenced cache page in the packfile
|
||||
* @return the position of the referenced cache page in the
|
||||
* {@link org.eclipse.jgit.internal.storage.file.Pack}
|
||||
*/
|
||||
long getPosition();
|
||||
|
||||
|
|
@ -844,7 +847,7 @@ private static interface PageRef<T> {
|
|||
/** A soft reference wrapped around a cached object. */
|
||||
private static class SoftRef extends SoftReference<ByteWindow>
|
||||
implements PageRef<ByteWindow> {
|
||||
private final PackFile pack;
|
||||
private final Pack pack;
|
||||
|
||||
private final long position;
|
||||
|
||||
|
|
@ -852,7 +855,7 @@ private static class SoftRef extends SoftReference<ByteWindow>
|
|||
|
||||
private long lastAccess;
|
||||
|
||||
protected SoftRef(final PackFile pack, final long position,
|
||||
protected SoftRef(final Pack pack, final long position,
|
||||
final ByteWindow v, final SoftCleanupQueue queue) {
|
||||
super(v, queue);
|
||||
this.pack = pack;
|
||||
|
|
@ -861,7 +864,7 @@ protected SoftRef(final PackFile pack, final long position,
|
|||
}
|
||||
|
||||
@Override
|
||||
public PackFile getPack() {
|
||||
public Pack getPack() {
|
||||
return pack;
|
||||
}
|
||||
|
||||
|
|
@ -900,7 +903,7 @@ public boolean isStrongRef() {
|
|||
private static class StrongRef implements PageRef<ByteWindow> {
|
||||
private ByteWindow referent;
|
||||
|
||||
private final PackFile pack;
|
||||
private final Pack pack;
|
||||
|
||||
private final long position;
|
||||
|
||||
|
|
@ -910,7 +913,7 @@ private static class StrongRef implements PageRef<ByteWindow> {
|
|||
|
||||
private CleanupQueue queue;
|
||||
|
||||
protected StrongRef(final PackFile pack, final long position,
|
||||
protected StrongRef(final Pack pack, final long position,
|
||||
final ByteWindow v, final CleanupQueue queue) {
|
||||
this.pack = pack;
|
||||
this.position = position;
|
||||
|
|
@ -920,7 +923,7 @@ protected StrongRef(final PackFile pack, final long position,
|
|||
}
|
||||
|
||||
@Override
|
||||
public PackFile getPack() {
|
||||
public Pack getPack() {
|
||||
return pack;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ public ObjectReader newReader() {
|
|||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public BitmapIndex getBitmapIndex() throws IOException {
|
||||
for (PackFile pack : db.getPacks()) {
|
||||
for (Pack pack : db.getPacks()) {
|
||||
PackBitmapIndex index = pack.getBitmapIndex();
|
||||
if (index != null)
|
||||
return new BitmapIndexImpl(index);
|
||||
|
|
@ -98,7 +98,7 @@ public BitmapIndex getBitmapIndex() throws IOException {
|
|||
@Override
|
||||
public Collection<CachedPack> getCachedPacksAndUpdate(
|
||||
BitmapBuilder needBitmap) throws IOException {
|
||||
for (PackFile pack : db.getPacks()) {
|
||||
for (Pack pack : db.getPacks()) {
|
||||
PackBitmapIndex index = pack.getBitmapIndex();
|
||||
if (needBitmap.removeAllOrNone(index))
|
||||
return Collections.<CachedPack> singletonList(
|
||||
|
|
@ -218,7 +218,7 @@ public void writeObjects(PackOutputStream out, List<ObjectToPack> list)
|
|||
* this cursor does not match the provider or id and the proper
|
||||
* window could not be acquired through the provider's cache.
|
||||
*/
|
||||
int copy(final PackFile pack, long position, final byte[] dstbuf,
|
||||
int copy(final Pack pack, long position, final byte[] dstbuf,
|
||||
int dstoff, final int cnt) throws IOException {
|
||||
final long length = pack.length;
|
||||
int need = cnt;
|
||||
|
|
@ -239,7 +239,7 @@ public void copyPackAsIs(PackOutputStream out, CachedPack pack)
|
|||
((LocalCachedPack) pack).copyAsIs(out, this);
|
||||
}
|
||||
|
||||
void copyPackAsIs(final PackFile pack, final long length,
|
||||
void copyPackAsIs(final Pack pack, final long length,
|
||||
final PackOutputStream out) throws IOException {
|
||||
long position = 12;
|
||||
long remaining = length - (12 + 20);
|
||||
|
|
@ -275,7 +275,7 @@ void copyPackAsIs(final PackFile pack, final long length,
|
|||
* the inflater encountered an invalid chunk of data. Data
|
||||
* stream corruption is likely.
|
||||
*/
|
||||
int inflate(final PackFile pack, long position, final byte[] dstbuf,
|
||||
int inflate(final Pack pack, long position, final byte[] dstbuf,
|
||||
boolean headerOnly) throws IOException, DataFormatException {
|
||||
prepareInflater();
|
||||
pin(pack, position);
|
||||
|
|
@ -293,7 +293,7 @@ int inflate(final PackFile pack, long position, final byte[] dstbuf,
|
|||
}
|
||||
}
|
||||
|
||||
ByteArrayWindow quickCopy(PackFile p, long pos, long cnt)
|
||||
ByteArrayWindow quickCopy(Pack p, long pos, long cnt)
|
||||
throws IOException {
|
||||
pin(p, pos);
|
||||
if (window instanceof ByteArrayWindow
|
||||
|
|
@ -314,7 +314,7 @@ private void prepareInflater() {
|
|||
inf.reset();
|
||||
}
|
||||
|
||||
void pin(PackFile pack, long position)
|
||||
void pin(Pack pack, long position)
|
||||
throws IOException {
|
||||
final ByteWindow w = window;
|
||||
if (w == null || !w.contains(pack, position)) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue