Robin Rosenberg
13 years ago
committed by
Gerrit Code Review @ Eclipse.org
9 changed files with 1368 additions and 2 deletions
@ -0,0 +1,58 @@
|
||||
/* |
||||
* Copyright (C) 2012, Christian Halstrick <christian.halstrick@sap.com> |
||||
* and other copyright owners as documented in the project's IP log. |
||||
* |
||||
* This program and the accompanying materials are made available |
||||
* under the terms of the Eclipse Distribution License v1.0 which |
||||
* accompanies this distribution, is reproduced below, and is |
||||
* available at http://www.eclipse.org/org/documents/edl-v10.php
|
||||
* |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or |
||||
* without modification, are permitted provided that the following |
||||
* conditions are met: |
||||
* |
||||
* - Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* |
||||
* - Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following |
||||
* disclaimer in the documentation and/or other materials provided |
||||
* with the distribution. |
||||
* |
||||
* - Neither the name of the Eclipse Foundation, Inc. nor the |
||||
* names of its contributors may be used to endorse or promote |
||||
* products derived from this software without specific prior |
||||
* written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
||||
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
||||
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
|
||||
package org.eclipse.jgit.pgm.debug; |
||||
|
||||
import org.eclipse.jgit.lib.TextProgressMonitor; |
||||
import org.eclipse.jgit.pgm.TextBuiltin; |
||||
import org.eclipse.jgit.storage.file.FileRepository; |
||||
import org.eclipse.jgit.storage.file.GC; |
||||
|
||||
class Gc extends TextBuiltin { |
||||
@Override |
||||
protected void run() throws Exception { |
||||
GC gc = new GC((FileRepository) db); |
||||
gc.setProgressMonitor(new TextProgressMonitor()); |
||||
gc.gc(); |
||||
} |
||||
} |
||||
@ -0,0 +1,348 @@
|
||||
/* |
||||
* Copyright (C) 2012, Christian Halstrick <christian.halstrick@sap.com> |
||||
* and other copyright owners as documented in the project's IP log. |
||||
* |
||||
* This program and the accompanying materials are made available |
||||
* under the terms of the Eclipse Distribution License v1.0 which |
||||
* accompanies this distribution, is reproduced below, and is |
||||
* available at http://www.eclipse.org/org/documents/edl-v10.php
|
||||
* |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or |
||||
* without modification, are permitted provided that the following |
||||
* conditions are met: |
||||
* |
||||
* - Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* |
||||
* - Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following |
||||
* disclaimer in the documentation and/or other materials provided |
||||
* with the distribution. |
||||
* |
||||
* - Neither the name of the Eclipse Foundation, Inc. nor the |
||||
* names of its contributors may be used to endorse or promote |
||||
* products derived from this software without specific prior |
||||
* written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
||||
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
||||
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
package org.eclipse.jgit.storage.file; |
||||
|
||||
import static org.junit.Assert.assertEquals; |
||||
import static org.junit.Assert.assertFalse; |
||||
import static org.junit.Assert.assertTrue; |
||||
|
||||
import java.io.File; |
||||
import java.util.Collection; |
||||
import java.util.Collections; |
||||
import java.util.Iterator; |
||||
|
||||
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; |
||||
import org.eclipse.jgit.junit.TestRepository; |
||||
import org.eclipse.jgit.junit.TestRepository.BranchBuilder; |
||||
import org.eclipse.jgit.lib.Constants; |
||||
import org.eclipse.jgit.lib.ObjectId; |
||||
import org.eclipse.jgit.revwalk.RevCommit; |
||||
import org.eclipse.jgit.storage.file.GC.RepoStatistics; |
||||
import org.eclipse.jgit.storage.file.PackIndex.MutableEntry; |
||||
import org.eclipse.jgit.util.FileUtils; |
||||
import org.junit.After; |
||||
import org.junit.Before; |
||||
import org.junit.Test; |
||||
|
||||
public class GCTest extends LocalDiskRepositoryTestCase { |
||||
private TestRepository<FileRepository> tr; |
||||
|
||||
private FileRepository repo; |
||||
|
||||
private GC gc; |
||||
|
||||
private RepoStatistics stats; |
||||
|
||||
@Before |
||||
public void setUp() throws Exception { |
||||
super.setUp(); |
||||
repo = createWorkRepository(); |
||||
tr = new TestRepository<FileRepository>((repo)); |
||||
gc = new GC(repo); |
||||
} |
||||
|
||||
@After |
||||
public void tearDown() throws Exception { |
||||
super.tearDown(); |
||||
} |
||||
|
||||
@Test |
||||
public void testPackAllObjectsInOnePack() throws Exception { |
||||
tr.branch("refs/heads/master").commit().add("A", "A").add("B", "B") |
||||
.create(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(4, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testKeepFiles() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
bb.commit().add("A", "A").add("B", "B").create(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
assertEquals(0, stats.numberOfPackFiles); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(4, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
|
||||
Iterator<PackFile> packIt = repo.getObjectDatabase().getPacks() |
||||
.iterator(); |
||||
PackFile singlePack = packIt.next(); |
||||
assertFalse(packIt.hasNext()); |
||||
File keepFile = new File(singlePack.getPackFile().getPath() + ".keep"); |
||||
assertFalse(keepFile.exists()); |
||||
assertTrue(keepFile.createNewFile()); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(4, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(2, stats.numberOfPackFiles); |
||||
|
||||
// check that no object is packed twice
|
||||
Iterator<PackFile> packs = repo.getObjectDatabase().getPacks() |
||||
.iterator(); |
||||
PackIndex ind1 = packs.next().getIndex(); |
||||
assertEquals(4, ind1.getObjectCount()); |
||||
PackIndex ind2 = packs.next().getIndex(); |
||||
assertEquals(4, ind2.getObjectCount()); |
||||
for (MutableEntry e: ind1) |
||||
if (ind2.hasObject(e.toObjectId())) |
||||
assertFalse( |
||||
"the following object is in both packfiles: " |
||||
+ e.toObjectId(), ind2.hasObject(e.toObjectId())); |
||||
} |
||||
|
||||
@Test |
||||
public void testPackRepoWithNoRefs() throws Exception { |
||||
tr.commit().add("A", "A").add("B", "B").create(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
assertEquals(0, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testPack2Commits() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testPackCommitsAndLooseOne() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
RevCommit first = bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
tr.update("refs/heads/master", first); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(2, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testNotPackTwice() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
RevCommit first = bb.commit().message("M").add("M", "M").create(); |
||||
bb.commit().message("B").add("B", "Q").create(); |
||||
bb.commit().message("A").add("A", "A").create(); |
||||
RevCommit second = tr.commit().parent(first).message("R").add("R", "Q") |
||||
.create(); |
||||
tr.update("refs/tags/t1", second); |
||||
|
||||
Collection<PackFile> oldPacks = tr.getRepository().getObjectDatabase() |
||||
.getPacks(); |
||||
assertEquals(0, oldPacks.size()); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(11, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
|
||||
gc.setExpireAgeMillis(0); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
|
||||
Iterator<PackFile> pIt = repo.getObjectDatabase().getPacks().iterator(); |
||||
long c = pIt.next().getObjectCount(); |
||||
if (c == 9) |
||||
assertEquals(2, pIt.next().getObjectCount()); |
||||
else { |
||||
assertEquals(2, c); |
||||
assertEquals(9, pIt.next().getObjectCount()); |
||||
} |
||||
} |
||||
|
||||
@Test |
||||
public void testPackCommitsAndLooseOneNoReflog() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
RevCommit first = bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
tr.update("refs/heads/master", first); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
|
||||
FileUtils.delete(new File(repo.getDirectory(), "logs/HEAD"), |
||||
FileUtils.RETRY | FileUtils.SKIP_MISSING); |
||||
FileUtils.delete( |
||||
new File(repo.getDirectory(), "logs/refs/heads/master"), |
||||
FileUtils.RETRY | FileUtils.SKIP_MISSING); |
||||
gc.gc(); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(4, stats.numberOfLooseObjects); |
||||
assertEquals(4, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testPackCommitsAndLooseOneWithPruneNow() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
RevCommit first = bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
tr.update("refs/heads/master", first); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.setExpireAgeMillis(0); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(2, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testPackCommitsAndLooseOneWithPruneNowNoReflog() |
||||
throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
RevCommit first = bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
tr.update("refs/heads/master", first); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
|
||||
FileUtils.delete(new File(repo.getDirectory(), "logs/HEAD"), |
||||
FileUtils.RETRY | FileUtils.SKIP_MISSING); |
||||
FileUtils.delete( |
||||
new File(repo.getDirectory(), "logs/refs/heads/master"), |
||||
FileUtils.RETRY | FileUtils.SKIP_MISSING); |
||||
gc.setExpireAgeMillis(0); |
||||
gc.gc(); |
||||
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(4, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testIndexSavesObjects() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
bb.commit().add("A", "A3"); // this new content in index should survive
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(9, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(1, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testIndexSavesObjectsWithPruneNow() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
bb.commit().add("A", "A3"); // this new content in index should survive
|
||||
stats = gc.getStatistics(); |
||||
assertEquals(9, stats.numberOfLooseObjects); |
||||
assertEquals(0, stats.numberOfPackedObjects); |
||||
gc.setExpireAgeMillis(0); |
||||
gc.gc(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(0, stats.numberOfLooseObjects); |
||||
assertEquals(8, stats.numberOfPackedObjects); |
||||
assertEquals(1, stats.numberOfPackFiles); |
||||
} |
||||
|
||||
@Test |
||||
public void testPruneNone() throws Exception { |
||||
BranchBuilder bb = tr.branch("refs/heads/master"); |
||||
bb.commit().add("A", "A").add("B", "B").create(); |
||||
bb.commit().add("A", "A2").add("B", "B2").create(); |
||||
new File(repo.getDirectory(), Constants.LOGS + "/refs/heads/master") |
||||
.delete(); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
gc.setExpireAgeMillis(0); |
||||
gc.prune(Collections.<ObjectId> emptySet()); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
tr.blob("x"); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(9, stats.numberOfLooseObjects); |
||||
gc.prune(Collections.<ObjectId> emptySet()); |
||||
stats = gc.getStatistics(); |
||||
assertEquals(8, stats.numberOfLooseObjects); |
||||
} |
||||
} |
||||
@ -0,0 +1,771 @@
|
||||
/* |
||||
* Copyright (C) 2012, Christian Halstrick <christian.halstrick@sap.com> |
||||
* Copyright (C) 2011, Shawn O. Pearce <spearce@spearce.org> |
||||
* and other copyright owners as documented in the project's IP log. |
||||
* |
||||
* This program and the accompanying materials are made available |
||||
* under the terms of the Eclipse Distribution License v1.0 which |
||||
* accompanies this distribution, is reproduced below, and is |
||||
* available at http://www.eclipse.org/org/documents/edl-v10.php
|
||||
* |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or |
||||
* without modification, are permitted provided that the following |
||||
* conditions are met: |
||||
* |
||||
* - Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* |
||||
* - Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following |
||||
* disclaimer in the documentation and/or other materials provided |
||||
* with the distribution. |
||||
* |
||||
* - Neither the name of the Eclipse Foundation, Inc. nor the |
||||
* names of its contributors may be used to endorse or promote |
||||
* products derived from this software without specific prior |
||||
* written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
||||
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
||||
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
package org.eclipse.jgit.storage.file; |
||||
|
||||
import java.io.File; |
||||
import java.io.FileOutputStream; |
||||
import java.io.IOException; |
||||
import java.io.OutputStream; |
||||
import java.nio.channels.Channels; |
||||
import java.nio.channels.FileChannel; |
||||
import java.text.MessageFormat; |
||||
import java.util.ArrayList; |
||||
import java.util.Collection; |
||||
import java.util.Collections; |
||||
import java.util.HashMap; |
||||
import java.util.HashSet; |
||||
import java.util.Iterator; |
||||
import java.util.LinkedList; |
||||
import java.util.List; |
||||
import java.util.Map; |
||||
import java.util.Map.Entry; |
||||
import java.util.Set; |
||||
|
||||
import org.eclipse.jgit.dircache.DirCacheIterator; |
||||
import org.eclipse.jgit.errors.CorruptObjectException; |
||||
import org.eclipse.jgit.errors.IncorrectObjectTypeException; |
||||
import org.eclipse.jgit.errors.MissingObjectException; |
||||
import org.eclipse.jgit.errors.NoWorkTreeException; |
||||
import org.eclipse.jgit.internal.JGitText; |
||||
import org.eclipse.jgit.lib.Constants; |
||||
import org.eclipse.jgit.lib.FileMode; |
||||
import org.eclipse.jgit.lib.NullProgressMonitor; |
||||
import org.eclipse.jgit.lib.ObjectId; |
||||
import org.eclipse.jgit.lib.ProgressMonitor; |
||||
import org.eclipse.jgit.lib.Ref; |
||||
import org.eclipse.jgit.revwalk.ObjectWalk; |
||||
import org.eclipse.jgit.revwalk.RevObject; |
||||
import org.eclipse.jgit.revwalk.RevWalk; |
||||
import org.eclipse.jgit.storage.pack.PackWriter; |
||||
import org.eclipse.jgit.treewalk.TreeWalk; |
||||
import org.eclipse.jgit.treewalk.filter.TreeFilter; |
||||
import org.eclipse.jgit.util.FileUtils; |
||||
|
||||
/** |
||||
* A garbage collector for git {@link FileRepository}. Instances of this class
|
||||
* are not thread-safe. Don't use the same instance from multiple threads. |
||||
* |
||||
* This class started as a copy of DfsGarbageCollector from Shawn O. Pearce |
||||
* adapted to FileRepositories. |
||||
*/ |
||||
public class GC { |
||||
private final FileRepository repo; |
||||
|
||||
private ProgressMonitor pm; |
||||
|
||||
private long expireAgeMillis; |
||||
|
||||
/** |
||||
* the refs which existed during the last call to {@link #repack()}. This is |
||||
* needed during {@link #prune(Set)} where we can optimize by looking at the |
||||
* difference between the current refs and the refs which existed during |
||||
* last {@link #repack()}. |
||||
*/ |
||||
private Map<String, Ref> lastPackedRefs; |
||||
|
||||
/** |
||||
* Holds the starting time of the last repack() execution. This is needed in |
||||
* prune() to inspect only those reflog entries which have been added since |
||||
* last repack(). |
||||
*/ |
||||
private long lastRepackTime; |
||||
|
||||
/** |
||||
* Creates a new garbage collector with default values. An expirationTime of |
||||
* two weeks and <code>null</code> as progress monitor will be used. |
||||
* |
||||
* @param repo |
||||
* the repo to work on |
||||
*/ |
||||
public GC(FileRepository repo) { |
||||
this.repo = repo; |
||||
this.pm = NullProgressMonitor.INSTANCE; |
||||
this.expireAgeMillis = 14 * 24 * 60 * 60 * 1000L; |
||||
} |
||||
|
||||
/** |
||||
* Runs a garbage collector on a {@link FileRepository}. It will |
||||
* <ul> |
||||
* <li>pack loose references into packed-refs</li> |
||||
* <li>repack all reachable objects into new pack files and delete the old |
||||
* pack files</li> |
||||
* <li>prune all loose objects which are now reachable by packs</li> |
||||
* </ul> |
||||
* |
||||
* @return the collection of {@link PackFile}'s which are newly created |
||||
* @throws IOException |
||||
*/ |
||||
public Collection<PackFile> gc() throws IOException { |
||||
packRefs(); |
||||
// TODO: implement reflog_expire(pm, repo);
|
||||
Collection<PackFile> newPacks = repack(); |
||||
prune(Collections.<ObjectId> emptySet()); |
||||
// TODO: implement rerere_gc(pm);
|
||||
return newPacks; |
||||
} |
||||
|
||||
/** |
||||
* Delete old pack files. What is 'old' is defined by specifying a set of |
||||
* old pack files and a set of new pack files. Each pack file contained in |
||||
* old pack files but not contained in new pack files will be deleted. |
||||
* |
||||
* @param oldPacks |
||||
* @param newPacks |
||||
* @param ignoreErrors |
||||
* <code>true</code> if we should ignore the fact that a certain |
||||
* pack files or index files couldn't be deleted. |
||||
* <code>false</code> if an exception should be thrown in such |
||||
* cases |
||||
* @throws IOException |
||||
* if a pack file couldn't be deleted and |
||||
* <code>ignoreErrors</code> is set to <code>false</code> |
||||
*/ |
||||
private void deleteOldPacks(Collection<PackFile> oldPacks, |
||||
Collection<PackFile> newPacks, boolean ignoreErrors) |
||||
throws IOException { |
||||
int deleteOptions = FileUtils.RETRY | FileUtils.SKIP_MISSING; |
||||
if (ignoreErrors) |
||||
deleteOptions |= FileUtils.IGNORE_ERRORS; |
||||
oldPackLoop: for (PackFile oldPack : oldPacks) { |
||||
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) |
||||
if (oldName.equals(newPack.getPackName())) |
||||
continue oldPackLoop; |
||||
|
||||
if (!oldPack.shouldBeKept()) { |
||||
oldPack.close(); |
||||
FileUtils.delete(nameFor(oldName, ".pack"), deleteOptions); |
||||
FileUtils.delete(nameFor(oldName, ".idx"), deleteOptions); |
||||
} |
||||
} |
||||
// close the complete object database. Thats my only chance to force
|
||||
// rescanning and to detect that certain pack files are now deleted.
|
||||
repo.getObjectDatabase().close(); |
||||
} |
||||
|
||||
/** |
||||
* Like "git prune-packed" this method tries to prune all loose objects |
||||
* which can be found in packs. If certain objects can't be pruned (e.g. |
||||
* because the filesystem delete operation fails) this is silently ignored. |
||||
* |
||||
* @throws IOException |
||||
*/ |
||||
public void prunePacked() throws IOException { |
||||
ObjectDirectory objdb = repo.getObjectDatabase(); |
||||
Collection<PackFile> packs = objdb.getPacks(); |
||||
File objects = repo.getObjectsDirectory(); |
||||
String[] fanout = objects.list(); |
||||
|
||||
if (fanout != null && fanout.length > 0) { |
||||
pm.beginTask(JGitText.get().pruneLoosePackedObjects, fanout.length); |
||||
try { |
||||
for (String d : fanout) { |
||||
pm.update(1); |
||||
if (d.length() != 2) |
||||
continue; |
||||
String[] entries = new File(objects, d).list(); |
||||
if (entries == null) |
||||
continue; |
||||
for (String e : entries) { |
||||
if (e.length() != Constants.OBJECT_ID_STRING_LENGTH - 2) |
||||
continue; |
||||
ObjectId id; |
||||
try { |
||||
id = ObjectId.fromString(d + e); |
||||
} catch (IllegalArgumentException notAnObject) { |
||||
// ignoring the file that does not represent loose
|
||||
// object
|
||||
continue; |
||||
} |
||||
boolean found = false; |
||||
for (PackFile p : packs) |
||||
if (p.hasObject(id)) { |
||||
found = true; |
||||
break; |
||||
} |
||||
if (found) |
||||
FileUtils.delete(objdb.fileFor(id), FileUtils.RETRY |
||||
| FileUtils.SKIP_MISSING |
||||
| FileUtils.IGNORE_ERRORS); |
||||
} |
||||
} |
||||
} finally { |
||||
pm.endTask(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Like "git prune" this method tries to prune all loose objects which are |
||||
* unreferenced. If certain objects can't be pruned (e.g. because the |
||||
* filesystem delete operation fails) this is silently ignored. |
||||
* |
||||
* @param objectsToKeep |
||||
* a set of objects which should explicitly not be pruned |
||||
* |
||||
* @throws IOException |
||||
*/ |
||||
public void prune(Set<ObjectId> objectsToKeep) |
||||
throws IOException { |
||||
long expireDate = (expireAgeMillis == 0) ? Long.MAX_VALUE : System |
||||
.currentTimeMillis() - expireAgeMillis; |
||||
|
||||
// Collect all loose objects which are old enough, not referenced from
|
||||
// the index and not in objectsToKeep
|
||||
Map<ObjectId, File> deletionCandidates = new HashMap<ObjectId, File>(); |
||||
Set<ObjectId> indexObjects = null; |
||||
File objects = repo.getObjectsDirectory(); |
||||
String[] fanout = objects.list(); |
||||
if (fanout != null && fanout.length > 0) { |
||||
pm.beginTask(JGitText.get().pruneLooseUnreferencedObjects, |
||||
fanout.length); |
||||
for (String d : fanout) { |
||||
pm.update(1); |
||||
if (d.length() != 2) |
||||
continue; |
||||
File[] entries = new File(objects, d).listFiles(); |
||||
if (entries == null) |
||||
continue; |
||||
for (File f : entries) { |
||||
String fName = f.getName(); |
||||
if (fName.length() != Constants.OBJECT_ID_STRING_LENGTH - 2) |
||||
continue; |
||||
if (f.lastModified() >= expireDate) |
||||
continue; |
||||
try { |
||||
ObjectId id = ObjectId.fromString(d + fName); |
||||
if (objectsToKeep.contains(id)) |
||||
continue; |
||||
if (indexObjects == null) |
||||
indexObjects = listNonHEADIndexObjects(); |
||||
if (indexObjects.contains(id)) |
||||
continue; |
||||
deletionCandidates.put(id, f); |
||||
} catch (IllegalArgumentException notAnObject) { |
||||
// ignoring the file that does not represent loose
|
||||
// object
|
||||
continue; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
if (deletionCandidates.isEmpty()) |
||||
return; |
||||
|
||||
// From the set of current refs remove all those which have been handled
|
||||
// during last repack(). Only those refs will survive which have been
|
||||
// added or modified since the last repack. Only these can save existing
|
||||
// loose refs from being pruned.
|
||||
Map<String, Ref> newRefs; |
||||
if (lastPackedRefs == null || lastPackedRefs.isEmpty()) |
||||
newRefs = getAllRefs(); |
||||
else { |
||||
newRefs = new HashMap<String, Ref>(); |
||||
for (Iterator<Map.Entry<String, Ref>> i = getAllRefs().entrySet() |
||||
.iterator(); i.hasNext();) { |
||||
Entry<String, Ref> newEntry = i.next(); |
||||
Ref old = lastPackedRefs.get(newEntry.getKey()); |
||||
if (!equals(newEntry.getValue(), old)) |
||||
newRefs.put(newEntry.getKey(), newEntry.getValue()); |
||||
} |
||||
} |
||||
|
||||
if (!newRefs.isEmpty()) { |
||||
// There are new/modified refs! Check which loose objects are now
|
||||
// referenced by these modified refs (or their reflogentries).
|
||||
// Remove these loose objects
|
||||
// from the deletionCandidates. When the last candidate is removed
|
||||
// leave this method.
|
||||
ObjectWalk w = new ObjectWalk(repo); |
||||
try { |
||||
for (Ref cr : newRefs.values()) |
||||
w.markStart(w.parseAny(cr.getObjectId())); |
||||
if (lastPackedRefs != null) |
||||
for (Ref lpr : lastPackedRefs.values()) |
||||
w.markUninteresting(w.parseAny(lpr.getObjectId())); |
||||
removeReferenced(deletionCandidates, w); |
||||
} finally { |
||||
w.dispose(); |
||||
} |
||||
} |
||||
|
||||
if (deletionCandidates.isEmpty()) |
||||
return; |
||||
|
||||
// Since we have not left the method yet there are still
|
||||
// deletionCandidates. Last chance for these objects not to be pruned is
|
||||
// that they are referenced by reflog entries. Even refs which currently
|
||||
// point to the same object as during last repack() may have
|
||||
// additional reflog entries not handled during last repack()
|
||||
ObjectWalk w = new ObjectWalk(repo); |
||||
try { |
||||
for (Ref ar : getAllRefs().values()) |
||||
for (ObjectId id : listRefLogObjects(ar, lastRepackTime)) |
||||
w.markStart(w.parseAny(id)); |
||||
if (lastPackedRefs != null) |
||||
for (Ref lpr : lastPackedRefs.values()) |
||||
w.markUninteresting(w.parseAny(lpr.getObjectId())); |
||||
removeReferenced(deletionCandidates, w); |
||||
} finally { |
||||
w.dispose(); |
||||
} |
||||
|
||||
if (deletionCandidates.isEmpty()) |
||||
return; |
||||
|
||||
// delete all candidates which have survived: these are unreferenced
|
||||
// loose objects
|
||||
for (File f : deletionCandidates.values()) |
||||
f.delete(); |
||||
|
||||
repo.getObjectDatabase().close(); |
||||
} |
||||
|
||||
/** |
||||
* Remove all entries from a map which key is the id of an object referenced |
||||
* by the given ObjectWalk |
||||
* |
||||
* @param id2File |
||||
* @param w |
||||
* @throws MissingObjectException |
||||
* @throws IncorrectObjectTypeException |
||||
* @throws IOException |
||||
*/ |
||||
private void removeReferenced(Map<ObjectId, File> id2File, |
||||
ObjectWalk w) throws MissingObjectException, |
||||
IncorrectObjectTypeException, IOException { |
||||
RevObject ro = w.next(); |
||||
while (ro != null) { |
||||
if (id2File.remove(ro.getId()) != null) |
||||
if (id2File.isEmpty()) |
||||
return; |
||||
ro = w.next(); |
||||
} |
||||
ro = w.nextObject(); |
||||
while (ro != null) { |
||||
if (id2File.remove(ro.getId()) != null) |
||||
if (id2File.isEmpty()) |
||||
return; |
||||
ro = w.nextObject(); |
||||
} |
||||
} |
||||
|
||||
private static boolean equals(Ref r1, Ref r2) { |
||||
if (r1 == null || r2 == null) |
||||
return false; |
||||
if (r1.isSymbolic()) { |
||||
if (!r2.isSymbolic()) |
||||
return false; |
||||
return r1.getTarget().getName().equals(r2.getTarget().getName()); |
||||
} else { |
||||
if (r2.isSymbolic()) |
||||
return false; |
||||
return r1.getObjectId().equals(r2.getObjectId()); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Packs all non-symbolic, loose refs into packed-refs. |
||||
* |
||||
* @throws IOException |
||||
*/ |
||||
public void packRefs() throws IOException { |
||||
Collection<Ref> refs = repo.getAllRefs().values(); |
||||
List<String> refsToBePacked = new ArrayList<String>(refs.size()); |
||||
pm.beginTask(JGitText.get().packRefs, refs.size()); |
||||
try { |
||||
for (Ref ref : refs) { |
||||
if (!ref.isSymbolic() && ref.getStorage().isLoose()) |
||||
refsToBePacked.add(ref.getName()); |
||||
pm.update(1); |
||||
} |
||||
((RefDirectory) repo.getRefDatabase()).pack(refsToBePacked); |
||||
} finally { |
||||
pm.endTask(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Packs all objects which reachable from any of the heads into one pack |
||||
* file. Additionally all objects which are not reachable from any head but |
||||
* which are reachable from any of the other refs (e.g. tags), special refs |
||||
* (e.g. FETCH_HEAD) or index are packed into a separate pack file. Objects |
||||
* included in pack files which have a .keep file associated are never |
||||
* repacked. All old pack files which existed before are deleted. |
||||
* |
||||
* @return a collection of the newly created pack files |
||||
* @throws IOException |
||||
* when during reading of refs, index, packfiles, objects, |
||||
* reflog-entries or during writing to the packfiles |
||||
* {@link IOException} occurs |
||||
*/ |
||||
public Collection<PackFile> repack() throws IOException { |
||||
Collection<PackFile> toBeDeleted = repo.getObjectDatabase().getPacks(); |
||||
|
||||
long time = System.currentTimeMillis(); |
||||
Map<String, Ref> refsBefore = getAllRefs(); |
||||
|
||||
Set<ObjectId> allHeads = new HashSet<ObjectId>(); |
||||
Set<ObjectId> nonHeads = new HashSet<ObjectId>(); |
||||
Set<ObjectId> tagTargets = new HashSet<ObjectId>(); |
||||
Set<ObjectId> indexObjects = listNonHEADIndexObjects(); |
||||
|
||||
for (Ref ref : refsBefore.values()) { |
||||
nonHeads.addAll(listRefLogObjects(ref, 0)); |
||||
if (ref.isSymbolic() || ref.getObjectId() == null) |
||||
continue; |
||||
if (ref.getName().startsWith(Constants.R_HEADS)) |
||||
allHeads.add(ref.getObjectId()); |
||||
else |
||||
nonHeads.add(ref.getObjectId()); |
||||
if (ref.getPeeledObjectId() != null) |
||||
tagTargets.add(ref.getPeeledObjectId()); |
||||
} |
||||
|
||||
List<PackIndex> excluded = new LinkedList<PackIndex>(); |
||||
for (PackFile f : repo.getObjectDatabase().getPacks()) |
||||
if (f.shouldBeKept()) |
||||
excluded.add(f.getIndex()); |
||||
|
||||
tagTargets.addAll(allHeads); |
||||
nonHeads.addAll(indexObjects); |
||||
|
||||
List<PackFile> ret = new ArrayList<PackFile>(2); |
||||
PackFile heads = null; |
||||
if (!allHeads.isEmpty()) { |
||||
heads = writePack(allHeads, Collections.<ObjectId> emptySet(), |
||||
tagTargets, excluded); |
||||
if (heads != null) { |
||||
ret.add(heads); |
||||
excluded.add(0, heads.getIndex()); |
||||
} |
||||
} |
||||
if (!nonHeads.isEmpty()) { |
||||
PackFile rest = writePack(nonHeads, allHeads, tagTargets, excluded); |
||||
if (rest != null) |
||||
ret.add(rest); |
||||
} |
||||
deleteOldPacks(toBeDeleted, ret, true); |
||||
prunePacked(); |
||||
|
||||
lastPackedRefs = refsBefore; |
||||
lastRepackTime = time; |
||||
return ret; |
||||
} |
||||
|
||||
/** |
||||
* @param ref |
||||
* the ref which log should be inspected |
||||
* @param minTime only reflog entries not older then this time are processed |
||||
* @return the {@link ObjectId}s contained in the reflog |
||||
* @throws IOException |
||||
*/ |
||||
private Set<ObjectId> listRefLogObjects(Ref ref, long minTime) throws IOException { |
||||
List<ReflogEntry> rlEntries = repo.getReflogReader(ref.getName()) |
||||
.getReverseEntries(); |
||||
if (rlEntries == null || rlEntries.isEmpty()) |
||||
return Collections.<ObjectId> emptySet(); |
||||
Set<ObjectId> ret = new HashSet<ObjectId>(); |
||||
for (ReflogEntry e : rlEntries) { |
||||
if (e.getWho().getWhen().getTime() < minTime) |
||||
break; |
||||
ret.add(e.getNewId()); |
||||
ObjectId oldId = e.getOldId(); |
||||
if (oldId != null && !ObjectId.zeroId().equals(oldId)) |
||||
ret.add(oldId); |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/** |
||||
* Returns a map of all refs and additional refs (e.g. FETCH_HEAD, |
||||
* MERGE_HEAD, ...) |
||||
* |
||||
* @return a map where names of refs point to ref objects |
||||
* @throws IOException |
||||
*/ |
||||
private Map<String, Ref> getAllRefs() throws IOException { |
||||
Map<String, Ref> ret = repo.getAllRefs(); |
||||
for (Ref ref : repo.getRefDatabase().getAdditionalRefs()) |
||||
ret.put(ref.getName(), ref); |
||||
return ret; |
||||
} |
||||
|
||||
/** |
||||
* Return a list of those objects in the index which differ from whats in |
||||
* HEAD |
||||
* |
||||
* @return a set of ObjectIds of changed objects in the index |
||||
* @throws IOException |
||||
* @throws CorruptObjectException |
||||
* @throws NoWorkTreeException |
||||
*/ |
||||
private Set<ObjectId> listNonHEADIndexObjects() |
||||
throws CorruptObjectException, IOException { |
||||
RevWalk revWalk = null; |
||||
try { |
||||
if (repo.getIndexFile() == null) |
||||
return Collections.emptySet(); |
||||
} catch (NoWorkTreeException e) { |
||||
return Collections.emptySet(); |
||||
} |
||||
TreeWalk treeWalk = new TreeWalk(repo); |
||||
try { |
||||
treeWalk.addTree(new DirCacheIterator(repo.readDirCache())); |
||||
ObjectId headID = repo.resolve(Constants.HEAD); |
||||
if (headID != null) { |
||||
revWalk = new RevWalk(repo); |
||||
treeWalk.addTree(revWalk.parseTree(headID)); |
||||
revWalk.dispose(); |
||||
revWalk = null; |
||||
} |
||||
|
||||
treeWalk.setFilter(TreeFilter.ANY_DIFF); |
||||
treeWalk.setRecursive(true); |
||||
Set<ObjectId> ret = new HashSet<ObjectId>(); |
||||
|
||||
while (treeWalk.next()) { |
||||
ObjectId objectId = treeWalk.getObjectId(0); |
||||
switch (treeWalk.getRawMode(0) & FileMode.TYPE_MASK) { |
||||
case FileMode.TYPE_MISSING: |
||||
case FileMode.TYPE_GITLINK: |
||||
continue; |
||||
case FileMode.TYPE_TREE: |
||||
case FileMode.TYPE_FILE: |
||||
case FileMode.TYPE_SYMLINK: |
||||
ret.add(objectId); |
||||
continue; |
||||
default: |
||||
throw new IOException(MessageFormat.format( |
||||
JGitText.get().corruptObjectInvalidMode3, String |
||||
.format("%o", Integer.valueOf(treeWalk |
||||
.getRawMode(0)), |
||||
(objectId == null) ? "null" |
||||
: objectId.name(), treeWalk |
||||
.getPathString(), repo |
||||
.getIndexFile()))); |
||||
} |
||||
} |
||||
return ret; |
||||
} finally { |
||||
if (revWalk != null) |
||||
revWalk.dispose(); |
||||
treeWalk.release(); |
||||
} |
||||
} |
||||
|
||||
private PackFile writePack(Set<? extends ObjectId> want, |
||||
Set<? extends ObjectId> have, Set<ObjectId> tagTargets, |
||||
List<PackIndex> excludeObjects) throws IOException { |
||||
File tmpPack = null; |
||||
File tmpIdx = null; |
||||
PackWriter pw = new PackWriter(repo); |
||||
try { |
||||
// prepare the PackWriter
|
||||
pw.setDeltaBaseAsOffset(true); |
||||
pw.setReuseDeltaCommits(false); |
||||
if (tagTargets != null) |
||||
pw.setTagTargets(tagTargets); |
||||
if (excludeObjects != null) |
||||
for (PackIndex idx : excludeObjects) |
||||
pw.excludeObjects(idx); |
||||
pw.preparePack(pm, want, have); |
||||
if (pw.getObjectCount() == 0) |
||||
return null; |
||||
|
||||
// create temporary files
|
||||
String id = pw.computeName().getName(); |
||||
File packdir = new File(repo.getObjectsDirectory(), "pack"); |
||||
tmpPack = File.createTempFile("gc_", ".pack_tmp", packdir); |
||||
tmpIdx = new File(packdir, tmpPack.getName().substring(0, |
||||
tmpPack.getName().lastIndexOf('.')) |
||||
+ ".idx_tmp"); |
||||
|
||||
if (!tmpIdx.createNewFile()) |
||||
throw new IOException(MessageFormat.format( |
||||
JGitText.get().cannotCreateIndexfile, tmpIdx.getPath())); |
||||
|
||||
// write the packfile
|
||||
FileChannel channel = new FileOutputStream(tmpPack).getChannel(); |
||||
OutputStream channelStream = Channels.newOutputStream(channel); |
||||
try { |
||||
pw.writePack(pm, pm, channelStream); |
||||
} finally { |
||||
channel.force(true); |
||||
channelStream.close(); |
||||
channel.close(); |
||||
} |
||||
|
||||
// write the packindex
|
||||
FileChannel idxChannel = new FileOutputStream(tmpIdx).getChannel(); |
||||
OutputStream idxStream = Channels.newOutputStream(idxChannel); |
||||
try { |
||||
pw.writeIndex(idxStream); |
||||
} finally { |
||||
idxChannel.force(true); |
||||
idxStream.close(); |
||||
idxChannel.close(); |
||||
} |
||||
|
||||
// rename the temporary files to real files
|
||||
File realPack = nameFor(id, ".pack"); |
||||
tmpPack.setReadOnly(); |
||||
File realIdx = nameFor(id, ".idx"); |
||||
realIdx.setReadOnly(); |
||||
boolean delete = true; |
||||
try { |
||||
if (!tmpPack.renameTo(realPack)) |
||||
return null; |
||||
delete = false; |
||||
if (!tmpIdx.renameTo(realIdx)) { |
||||
File newIdx = new File(realIdx.getParentFile(), |
||||
realIdx.getName() + ".new"); |
||||
if (!tmpIdx.renameTo(newIdx)) |
||||
newIdx = tmpIdx; |
||||
throw new IOException(MessageFormat.format( |
||||
JGitText.get().panicCantRenameIndexFile, newIdx, |
||||
realIdx)); |
||||
} |
||||
} finally { |
||||
if (delete && tmpPack.exists()) |
||||
tmpPack.delete(); |
||||
if (delete && tmpIdx.exists()) |
||||
tmpIdx.delete(); |
||||
} |
||||
return repo.getObjectDatabase().openPack(realPack, realIdx); |
||||
} finally { |
||||
pw.release(); |
||||
if (tmpPack != null && tmpPack.exists()) |
||||
tmpPack.delete(); |
||||
if (tmpIdx != null && tmpIdx.exists()) |
||||
tmpIdx.delete(); |
||||
} |
||||
} |
||||
|
||||
private File nameFor(String name, String ext) { |
||||
File packdir = new File(repo.getObjectsDirectory(), "pack"); |
||||
return new File(packdir, "pack-" + name + ext); |
||||
} |
||||
|
||||
/** |
||||
* A class holding statistical data for a FileRepository regarding how many |
||||
* objects are stored as loose or packed objects |
||||
*/ |
||||
public class RepoStatistics { |
||||
/** |
||||
* The number of objects stored in pack files. If the same object is |
||||
* stored in multiple pack files then it is counted as often as it |
||||
* occurs in pack files. |
||||
*/ |
||||
public long numberOfPackedObjects; |
||||
|
||||
/** |
||||
* The number of pack files |
||||
*/ |
||||
public long numberOfPackFiles; |
||||
|
||||
/** |
||||
* The number of objects stored as loose objects. |
||||
*/ |
||||
public long numberOfLooseObjects; |
||||
} |
||||
|
||||
/** |
||||
* Returns the number of objects stored in pack files. If an object is |
||||
* contained in multiple pack files it is counted as often as it occurs. |
||||
* |
||||
* @return the number of objects stored in pack files |
||||
* @throws IOException |
||||
*/ |
||||
public RepoStatistics getStatistics() throws IOException { |
||||
RepoStatistics ret = new RepoStatistics(); |
||||
Collection<PackFile> packs = repo.getObjectDatabase().getPacks(); |
||||
for (PackFile f : packs) |
||||
ret.numberOfPackedObjects += f.getIndex().getObjectCount(); |
||||
ret.numberOfPackFiles = packs.size(); |
||||
File objDir = repo.getObjectsDirectory(); |
||||
String[] fanout = objDir.list(); |
||||
if (fanout != null && fanout.length > 0) { |
||||
for (String d : fanout) { |
||||
if (d.length() != 2) |
||||
continue; |
||||
String[] entries = new File(objDir, d).list(); |
||||
if (entries == null) |
||||
continue; |
||||
for (String e : entries) { |
||||
if (e.length() != Constants.OBJECT_ID_STRING_LENGTH - 2) |
||||
continue; |
||||
ret.numberOfLooseObjects++; |
||||
} |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/** |
||||
* Set the progress monitor used for garbage collection methods. |
||||
* |
||||
* @param pm |
||||
* @return this |
||||
*/ |
||||
public GC setProgressMonitor(ProgressMonitor pm) { |
||||
this.pm = (pm == null) ? NullProgressMonitor.INSTANCE : pm; |
||||
return this; |
||||
} |
||||
|
||||
/** |
||||
* During gc() or prune() each unreferenced, loose object which has been |
||||
* created or modified in the last <code>expireAgeMillis</code> milliseconds |
||||
* will not be pruned. Only older objects may be pruned. If set to 0 then |
||||
* every object is a candidate for pruning. |
||||
* |
||||
* @param expireAgeMillis |
||||
* minimal age of objects to be pruned in milliseconds. |
||||
*/ |
||||
public void setExpireAgeMillis(long expireAgeMillis) { |
||||
this.expireAgeMillis = expireAgeMillis; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue