diff options
7 files changed, 243 insertions, 48 deletions
diff --git a/org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildRefTree.java b/org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildRefTree.java index 78ca1a7128..fbd4672f28 100644 --- a/org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildRefTree.java +++ b/org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/RebuildRefTree.java @@ -43,9 +43,11 @@ package org.eclipse.jgit.pgm.debug; +import static org.eclipse.jgit.lib.Constants.HEAD; + +import java.io.IOException; import java.util.ArrayList; import java.util.List; -import java.util.Map; import org.eclipse.jgit.internal.storage.reftree.RefTree; import org.eclipse.jgit.internal.storage.reftree.RefTreeDatabase; @@ -57,12 +59,17 @@ import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefDatabase; import org.eclipse.jgit.lib.RefUpdate; +import org.eclipse.jgit.lib.StoredConfig; import org.eclipse.jgit.pgm.Command; import org.eclipse.jgit.pgm.TextBuiltin; import org.eclipse.jgit.revwalk.RevWalk; +import org.kohsuke.args4j.Option; @Command(usage = "usage_RebuildRefTree") class RebuildRefTree extends TextBuiltin { + @Option(name = "--enable", usage = "set extensions.refsStorage = reftree") + boolean enable; + private String txnNamespace; private String txnCommitted; @@ -103,7 +110,7 @@ class RebuildRefTree extends TextBuiltin { oldTreeId = ObjectId.zeroId(); } - RefTree tree = rebuild(refDb.getRefs(RefDatabase.ALL)); + RefTree tree = rebuild(refDb); b.setTreeId(tree.writeTree(inserter)); b.setAuthor(new PersonIdent(db)); b.setCommitter(b.getAuthor()); @@ -122,15 +129,31 @@ class RebuildRefTree extends TextBuiltin { default: throw die(String.format("%s: %s", update.getName(), result)); //$NON-NLS-1$ } + + if (enable && !(db.getRefDatabase() instanceof RefTreeDatabase)) { + StoredConfig cfg = db.getConfig(); + cfg.setInt("core", null, "repositoryformatversion", 1); //$NON-NLS-1$ //$NON-NLS-2$ + cfg.setString("extensions", null, "refsStorage", "reftree"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + cfg.save(); + errw.println("Enabled reftree."); //$NON-NLS-1$ + errw.flush(); + } } } - private RefTree rebuild(Map<String, Ref> refMap) { + private RefTree rebuild(RefDatabase refdb) throws IOException { RefTree tree = RefTree.newEmptyTree(); List<org.eclipse.jgit.internal.storage.reftree.Command> cmds = new ArrayList<>(); - for (Ref r : refMap.values()) { + Ref head = refdb.exactRef(HEAD); + if (head != null) { + cmds.add(new org.eclipse.jgit.internal.storage.reftree.Command( + null, + head)); + } + + for (Ref r : refdb.getRefs(RefDatabase.ALL).values()) { if (r.getName().equals(txnCommitted) || r.getName().startsWith(txnNamespace)) { continue; diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/LocalDiskRefTreeDatabaseTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/LocalDiskRefTreeDatabaseTest.java new file mode 100644 index 0000000000..47f70d7bdb --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/LocalDiskRefTreeDatabaseTest.java @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2016 Google Inc. + * 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.internal.storage.reftree; + +import static org.eclipse.jgit.lib.Constants.HEAD; +import static org.eclipse.jgit.lib.Constants.MASTER; +import static org.eclipse.jgit.lib.Constants.ORIG_HEAD; +import static org.eclipse.jgit.lib.Constants.R_HEADS; +import static org.eclipse.jgit.lib.RefDatabase.ALL; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.io.File; +import java.io.IOException; +import java.util.List; + +import org.eclipse.jgit.internal.storage.file.FileRepository; +import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; +import org.eclipse.jgit.junit.TestRepository; +import org.eclipse.jgit.lib.ObjectId; +import org.eclipse.jgit.lib.Ref; +import org.eclipse.jgit.lib.RefDatabase; +import org.eclipse.jgit.lib.RefUpdate; +import org.eclipse.jgit.revwalk.RevCommit; +import org.eclipse.jgit.storage.file.FileBasedConfig; +import org.eclipse.jgit.storage.file.FileRepositoryBuilder; +import org.junit.Before; +import org.junit.Test; + +public class LocalDiskRefTreeDatabaseTest extends LocalDiskRepositoryTestCase { + private FileRepository repo; + private RefTreeDatabase refdb; + private RefDatabase bootstrap; + + private TestRepository<FileRepository> testRepo; + private RevCommit A; + private RevCommit B; + + @Before + public void setUp() throws Exception { + FileRepository init = createWorkRepository(); + FileBasedConfig cfg = init.getConfig(); + cfg.setInt("core", null, "repositoryformatversion", 1); + cfg.setString("extensions", null, "refsStorage", "reftree"); + cfg.save(); + + repo = (FileRepository) new FileRepositoryBuilder() + .setGitDir(init.getDirectory()) + .build(); + refdb = (RefTreeDatabase) repo.getRefDatabase(); + bootstrap = refdb.getBootstrap(); + addRepoToClose(repo); + + RefUpdate head = refdb.newUpdate(HEAD, true); + head.link(R_HEADS + MASTER); + + testRepo = new TestRepository<>(init); + A = testRepo.commit().create(); + B = testRepo.commit(testRepo.getRevWalk().parseCommit(A)); + } + + @Test + public void testHeadOrigHead() throws IOException { + RefUpdate master = refdb.newUpdate(HEAD, false); + master.setExpectedOldObjectId(ObjectId.zeroId()); + master.setNewObjectId(A); + assertEquals(RefUpdate.Result.NEW, master.update()); + assertEquals(A, refdb.exactRef(HEAD).getObjectId()); + + RefUpdate orig = refdb.newUpdate(ORIG_HEAD, true); + orig.setNewObjectId(B); + assertEquals(RefUpdate.Result.NEW, orig.update()); + + File origFile = new File(repo.getDirectory(), ORIG_HEAD); + assertEquals(B.name() + '\n', read(origFile)); + assertEquals(B, bootstrap.exactRef(ORIG_HEAD).getObjectId()); + assertEquals(B, refdb.exactRef(ORIG_HEAD).getObjectId()); + assertFalse(refdb.getRefs(ALL).containsKey(ORIG_HEAD)); + + List<Ref> addl = refdb.getAdditionalRefs(); + assertEquals(2, addl.size()); + assertEquals(ORIG_HEAD, addl.get(1).getName()); + assertEquals(B, addl.get(1).getObjectId()); + } +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabaseTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabaseTest.java index 020d1b1b51..e4d0f1d291 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabaseTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabaseTest.java @@ -44,6 +44,7 @@ package org.eclipse.jgit.internal.storage.reftree; import static org.eclipse.jgit.lib.Constants.HEAD; +import static org.eclipse.jgit.lib.Constants.ORIG_HEAD; import static org.eclipse.jgit.lib.Constants.R_HEADS; import static org.eclipse.jgit.lib.Constants.R_TAGS; import static org.eclipse.jgit.lib.Ref.Storage.LOOSE; @@ -124,6 +125,17 @@ public class RefTreeDatabaseTest { assertTrue("no references", refdb.getRefs(ALL).isEmpty()); assertTrue("no references", refdb.getRefs(R_HEADS).isEmpty()); assertTrue("no references", refdb.getRefs(R_TAGS).isEmpty()); + assertTrue("no references", refdb.getAdditionalRefs().isEmpty()); + } + + @Test + public void testGetAdditionalRefs() throws IOException { + update("refs/heads/master", A); + + List<Ref> addl = refdb.getAdditionalRefs(); + assertEquals(1, addl.size()); + assertEquals("refs/txn/committed", addl.get(0).getName()); + assertEquals(getTxnCommitted(), addl.get(0).getObjectId()); } @Test @@ -457,6 +469,27 @@ public class RefTreeDatabaseTest { } @Test + public void testUpdate_RefusesOrigHeadOnBare() throws IOException { + assertTrue(refdb.getRepository().isBare()); + ObjectId txnId = getTxnCommitted(); + + RefUpdate orig = refdb.newUpdate(ORIG_HEAD, true); + orig.setNewObjectId(B); + assertEquals(RefUpdate.Result.LOCK_FAILURE, orig.update()); + assertEquals(txnId, getTxnCommitted()); + + ReceiveCommand cmd = command(null, B, ORIG_HEAD); + BatchRefUpdate batch = refdb.newBatchUpdate(); + batch.addCommand(cmd); + batch.execute(new RevWalk(repo), NullProgressMonitor.INSTANCE); + assertEquals(REJECTED_OTHER_REASON, cmd.getResult()); + assertEquals( + MessageFormat.format(JGitText.get().invalidRefName, ORIG_HEAD), + cmd.getMessage()); + assertEquals(txnId, getTxnCommitted()); + } + + @Test public void testBatchRefUpdate_NonFastForwardAborts() throws IOException { update("refs/heads/master", A); update("refs/heads/masters", B); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java index 784507d88c..33be3b15a8 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java @@ -194,7 +194,7 @@ public class DfsGarbageCollector { refdb.refresh(); objdb.clearCache(); - Collection<Ref> refsBefore = RefTreeNames.allRefs(refdb); + Collection<Ref> refsBefore = getAllRefs(); packsBefore = packsToRebuild(); if (packsBefore.isEmpty()) return true; @@ -235,6 +235,18 @@ public class DfsGarbageCollector { } } + private Collection<Ref> getAllRefs() throws IOException { + Collection<Ref> refs = refdb.getRefs(RefDatabase.ALL).values(); + List<Ref> addl = refdb.getAdditionalRefs(); + if (!addl.isEmpty()) { + List<Ref> all = new ArrayList<>(refs.size() + addl.size()); + all.addAll(refs); + all.addAll(addl); + return all; + } + return refs; + } + private List<DfsPackFile> packsToRebuild() throws IOException { DfsPackFile[] packs = objdb.getPacks(); List<DfsPackFile> out = new ArrayList<DfsPackFile>(packs.length); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java index 2ce0d47348..49f9335aed 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java @@ -629,15 +629,16 @@ public class GC { } /** - * Returns a map of all refs and additional refs (e.g. FETCH_HEAD, + * Returns a collection of all refs and additional refs (e.g. FETCH_HEAD, * MERGE_HEAD, ...) * - * @return a map where names of refs point to ref objects + * @return a collection of refs pointing to live objects. * @throws IOException */ private Collection<Ref> getAllRefs() throws IOException { - Collection<Ref> refs = RefTreeNames.allRefs(repo.getRefDatabase()); - List<Ref> addl = repo.getRefDatabase().getAdditionalRefs(); + RefDatabase refdb = repo.getRefDatabase(); + Collection<Ref> refs = refdb.getRefs(RefDatabase.ALL).values(); + List<Ref> addl = refdb.getAdditionalRefs(); if (!addl.isEmpty()) { List<Ref> all = new ArrayList<>(refs.size() + addl.size()); all.addAll(refs); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabase.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabase.java index dc60311102..df93ce88af 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabase.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeDatabase.java @@ -43,10 +43,13 @@ package org.eclipse.jgit.internal.storage.reftree; +import static org.eclipse.jgit.lib.Constants.HEAD; import static org.eclipse.jgit.lib.Ref.Storage.LOOSE; import static org.eclipse.jgit.lib.Ref.Storage.PACKED; import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -187,12 +190,19 @@ public class RefTreeDatabase extends RefDatabase { @Override public Ref getRef(String name) throws IOException { - return findRef(getRefs(ALL), name); + String[] needle = new String[SEARCH_PATH.length]; + for (int i = 0; i < SEARCH_PATH.length; i++) { + needle[i] = SEARCH_PATH[i] + name; + } + return firstExactRef(needle); } @Override public Ref exactRef(String name) throws IOException { - if (conflictsWithBootstrap(name)) { + if (!repo.isBare() && name.indexOf('/') < 0 && !HEAD.equals(name)) { + // Pass through names like MERGE_HEAD, ORIG_HEAD, FETCH_HEAD. + return bootstrap.exactRef(name); + } else if (conflictsWithBootstrap(name)) { return null; } @@ -250,7 +260,23 @@ public class RefTreeDatabase extends RefDatabase { @Override public List<Ref> getAdditionalRefs() throws IOException { - return Collections.emptyList(); + Collection<Ref> txnRefs; + if (txnNamespace != null) { + txnRefs = bootstrap.getRefs(txnNamespace).values(); + } else { + Ref r = bootstrap.exactRef(txnCommitted); + if (r != null && r.getObjectId() != null) { + txnRefs = Collections.singleton(r); + } else { + txnRefs = Collections.emptyList(); + } + } + + List<Ref> otherRefs = bootstrap.getAdditionalRefs(); + List<Ref> all = new ArrayList<>(txnRefs.size() + otherRefs.size()); + all.addAll(txnRefs); + all.addAll(otherRefs); + return all; } @Override @@ -293,6 +319,9 @@ public class RefTreeDatabase extends RefDatabase { @Override public RefUpdate newUpdate(String name, boolean detach) throws IOException { + if (!repo.isBare() && name.indexOf('/') < 0 && !HEAD.equals(name)) { + return bootstrap.newUpdate(name, detach); + } if (conflictsWithBootstrap(name)) { return new AlwaysFailUpdate(this, name); } @@ -327,7 +356,13 @@ public class RefTreeDatabase extends RefDatabase { return true; } else if (txnCommitted.equals(name)) { return true; - } else if (name.length() > txnCommitted.length() + } + + if (name.indexOf('/') < 0 && !HEAD.equals(name)) { + return true; + } + + if (name.length() > txnCommitted.length() && name.charAt(txnCommitted.length()) == '/' && name.startsWith(txnCommitted)) { return true; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeNames.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeNames.java index 239a745277..c53d6deb21 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeNames.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/RefTreeNames.java @@ -43,14 +43,6 @@ package org.eclipse.jgit.internal.storage.reftree; -import static org.eclipse.jgit.lib.RefDatabase.ALL; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefDatabase; /** Magic reference name logic for RefTrees. */ @@ -92,33 +84,6 @@ public class RefTreeNames { return false; } - /** - * Snapshot all references from a RefTreeDatabase and its bootstrap. - * <p> - * There may be name conflicts with multiple {@link Ref} objects containing - * the same name in the returned collection. - * - * @param refdb - * database instance. - * @return all known references. - * @throws IOException - * references cannot be enumerated. - */ - public static Collection<Ref> allRefs(RefDatabase refdb) - throws IOException { - Collection<Ref> refs = refdb.getRefs(ALL).values(); - if (!(refdb instanceof RefTreeDatabase)) { - return refs; - } - - RefDatabase bootstrap = ((RefTreeDatabase) refdb).getBootstrap(); - Collection<Ref> br = bootstrap.getRefs(ALL).values(); - List<Ref> all = new ArrayList<>(refs.size() + br.size()); - all.addAll(refs); - all.addAll(br); - return all; - } - private RefTreeNames() { } } |