[535200] Create a new TreeWalk instead reusing one
In order to avoid side effects this commits create a new TreeWalk to
create the TreeWalkResourceVariantTreeProvider instead of using the one
given by JGit
Bug: 535200
Change-Id: I1b8621a488db2dc4842d250b95e07312013e648a
diff --git a/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/RecursiveModelMerger.java b/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/RecursiveModelMerger.java
index a64cc3d..46d5ff2 100644
--- a/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/RecursiveModelMerger.java
+++ b/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/RecursiveModelMerger.java
@@ -52,6 +52,8 @@
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.merge.MergeResult;
import org.eclipse.jgit.merge.RecursiveMerger;
+import org.eclipse.jgit.revwalk.RevTree;
+import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.eclipse.jgit.treewalk.TreeWalk;
@@ -105,6 +107,12 @@
*/
private final Set<String> handledPaths = new HashSet<>();
+ private AbstractTreeIterator aBaseTree;
+
+ private RevTree aHeadTree;
+
+ private RevTree aMergeTree;
+
/**
* Default recursive model merger.
*
@@ -116,12 +124,30 @@
}
@Override
+ protected boolean mergeTrees(AbstractTreeIterator baseTree, RevTree headTree, RevTree mergeTree,
+ boolean ignoreConflicts) throws IOException {
+ // We need to keep track on all version to be merged to be able to build a new TreeWalk in
+ // #mergeTreeWalk
+ this.aBaseTree = baseTree;
+ this.aHeadTree = headTree;
+ this.aMergeTree = mergeTree;
+ return super.mergeTrees(baseTree, headTree, mergeTree, ignoreConflicts);
+ }
+
+ @Override
protected boolean mergeTreeWalk(TreeWalk treeWalk, boolean ignoreConflicts) throws IOException {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("STARTING Recursive model merge."); //$NON-NLS-1$
}
- final TreeWalkResourceVariantTreeProvider variantTreeProvider = new TreeWalkResourceVariantTreeProvider(
- getRepository(), treeWalk, T_BASE, T_OURS, T_THEIRS);
+ final TreeWalkResourceVariantTreeProvider variantTreeProvider = new TreeWalkResourceVariantTreeProvider.Builder()//
+ .setRepository(getRepository())//
+ .setaBaseTree(aBaseTree)//
+ .setHeadTree(aHeadTree)//
+ .setMergeTree(aMergeTree)//
+ .setDircache(dircache) //
+ .setReader(reader) //
+ .build();
+
final GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(
variantTreeProvider);
final RemoteResourceMappingContext remoteMappingContext = new SubscriberResourceMappingContext(
diff --git a/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/TreeWalkResourceVariantTreeProvider.java b/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/TreeWalkResourceVariantTreeProvider.java
index 989b9e0..f6a2204 100644
--- a/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/TreeWalkResourceVariantTreeProvider.java
+++ b/plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/TreeWalkResourceVariantTreeProvider.java
@@ -29,11 +29,17 @@
import org.eclipse.egit.core.GitProvider;
import org.eclipse.egit.core.internal.util.ResourceUtil;
import org.eclipse.emf.compare.egit.internal.storage.TreeParserResourceVariant;
+import org.eclipse.jgit.dircache.DirCache;
+import org.eclipse.jgit.dircache.DirCacheBuildIterator;
+import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
-import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.treewalk.FileTreeIterator;
+import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.variants.IResourceVariantTree;
@@ -59,117 +65,16 @@
private final Set<IResource> knownResources;
- private final LinkedHashMap<IPath, IProject> map = new LinkedHashMap<IPath, IProject>();
+ private final LinkedHashMap<IPath, IProject> map;
- /**
- * Constructs the resource variant trees by iterating over the given tree walk. This TreeWalk must contain
- * at least three trees corresponding to the three "sides" we need.
- * <p>
- * The tree walk will be reset to its initial state when we are done with the iteration.
- * </p>
- *
- * @param repository
- * The repository this tree walk has been created for.
- * @param treeWalk
- * The tree walk to iterate over.
- * @param baseIndex
- * Index of the ancestor tree in the given TreeWalk (value returned by
- * {@link TreeWalk#addTree(AbstractTreeIterator)})
- * @param ourIndex
- * Index of our tree in the given TreeWalk (value returned by
- * {@link TreeWalk#addTree(AbstractTreeIterator)})
- * @param theirIndex
- * Index of their tree in the given TreeWalk (value returned by
- * {@link TreeWalk#addTree(AbstractTreeIterator)})
- * @throws IOException
- * if we somehow cannot iterate over the treewalk.
- */
- public TreeWalkResourceVariantTreeProvider(Repository repository, TreeWalk treeWalk, int baseIndex,
- int ourIndex, int theirIndex) throws IOException {
- // Record the initial state of this tree walk before iterating
- final AbstractTreeIterator[] initialTrees = new AbstractTreeIterator[treeWalk.getTreeCount()];
- for (int i = 0; i < treeWalk.getTreeCount(); i++) {
- initialTrees[i] = treeWalk.getTree(i, AbstractTreeIterator.class);
- }
+ private TreeWalkResourceVariantTreeProvider(Builder builder) {
- final GitResourceVariantCache baseCache = new GitResourceVariantCache();
- final GitResourceVariantCache theirsCache = new GitResourceVariantCache();
- final GitResourceVariantCache oursCache = new GitResourceVariantCache();
-
- while (treeWalk.next()) {
- final int modeBase = treeWalk.getRawMode(baseIndex);
- final int modeOurs = treeWalk.getRawMode(ourIndex);
- final int modeTheirs = treeWalk.getRawMode(theirIndex);
- if (!hasSignificantDifference(modeBase, modeOurs, modeTheirs)) {
- // conflict on file modes, leave the default merger handle it
- continue;
- }
-
- final CanonicalTreeParser base = treeWalk.getTree(baseIndex, CanonicalTreeParser.class);
- final CanonicalTreeParser ours = treeWalk.getTree(ourIndex, CanonicalTreeParser.class);
- final CanonicalTreeParser theirs = treeWalk.getTree(theirIndex, CanonicalTreeParser.class);
-
- final int nonZeroMode = modeBase != 0 ? modeBase : modeOurs != 0 ? modeOurs : modeTheirs;
- final IResource resource = getResourceHandleForLocation(repository, treeWalk.getPathString(),
- FileMode.fromBits(nonZeroMode) == FileMode.TREE);
-
- // Resource variants only make sense for IResources.
- if (resource != null) {
- IPath workspacePath = resource.getFullPath();
- if (modeBase != 0) {
- baseCache.setVariant(resource,
- TreeParserResourceVariant.create(repository, base, workspacePath));
- }
- if (modeOurs != 0) {
- oursCache.setVariant(resource,
- TreeParserResourceVariant.create(repository, ours, workspacePath));
- }
- if (modeTheirs != 0) {
- theirsCache.setVariant(resource,
- TreeParserResourceVariant.create(repository, theirs, workspacePath));
- }
- }
-
- if (treeWalk.isSubtree()) {
- treeWalk.enterSubtree();
- }
- }
-
- // TODO any better way to reset the tree walk after an iteration?
- treeWalk.reset();
- for (int i = 0; i < initialTrees.length; i++) {
- initialTrees[i].reset();
- treeWalk.addTree(initialTrees[i]);
- }
-
- baseTree = new GitCachedResourceVariantTree(baseCache);
- theirsTree = new GitCachedResourceVariantTree(theirsCache);
- oursTree = new GitCachedResourceVariantTree(oursCache);
-
- roots = new LinkedHashSet<IResource>();
- roots.addAll(baseCache.getRoots());
- roots.addAll(oursCache.getRoots());
- roots.addAll(theirsCache.getRoots());
-
- knownResources = new LinkedHashSet<IResource>();
- knownResources.addAll(baseCache.getKnownResources());
- knownResources.addAll(oursCache.getKnownResources());
- knownResources.addAll(theirsCache.getKnownResources());
- }
-
- private boolean hasSignificantDifference(int modeBase, int modeOurs, int modeTheirs) {
- if (modeBase == 0) {
- if (FileMode.fromBits(modeOurs | modeTheirs) != FileMode.MISSING) {
- return true;
- } else {
- return (FileMode.fromBits(modeOurs) == FileMode.TREE
- && FileMode.fromBits(modeTheirs) != FileMode.TREE)
- || (FileMode.fromBits(modeOurs) != FileMode.TREE
- && FileMode.fromBits(modeTheirs) == FileMode.TREE);
- }
- }
- return FileMode.fromBits(modeBase & modeOurs) != FileMode.MISSING
- || FileMode.fromBits(modeBase & modeTheirs) != FileMode.MISSING;
+ this.map = builder.map;
+ this.baseTree = builder.baseTree;
+ this.theirsTree = builder.theirsTree;
+ this.oursTree = builder.oursTree;
+ this.roots = builder.roots;
+ this.knownResources = builder.knownResources;
}
public IResourceVariantTree getBaseTree() {
@@ -206,6 +111,26 @@
*/
public IResource getResourceHandleForLocation(Repository repository, String repoRelativePath,
boolean isFolder) {
+ return getResourceHandleForLocation(repository, repoRelativePath, isFolder, map);
+
+ }
+
+ /**
+ * Returns a resource handle for this path in the workspace. Note that neither the resource nor the result
+ * need exist in the workspace : this may return inexistent or otherwise non-accessible IResources.
+ *
+ * @param repository
+ * The repository within which is tracked this file.
+ * @param repoRelativePath
+ * Repository-relative path of the file we need an handle for.
+ * @param isFolder
+ * <code>true</code> if the file being sought is a folder.
+ * @param map
+ * a to keeps tracks of IPath to IProject
+ * @return The resource handle for the given path in the workspace.
+ */
+ private static IResource getResourceHandleForLocation(Repository repository, String repoRelativePath,
+ boolean isFolder, LinkedHashMap<IPath, IProject> map) {
IResource resource = null;
final String workDir = repository.getWorkTree().getAbsolutePath();
@@ -271,5 +196,171 @@
return resource;
}
+
+ public static class Builder {
+
+ private Repository repository;
+
+ private AbstractTreeIterator aBaseTree;
+
+ private RevTree headTree;
+
+ private RevTree mergeTree;
+
+ private DirCache dircache;
+
+ private ObjectReader reader;
+
+ private IResourceVariantTree baseTree;
+
+ private IResourceVariantTree oursTree;
+
+ private IResourceVariantTree theirsTree;
+
+ private Set<IResource> roots;
+
+ private Set<IResource> knownResources;
+
+ private GitResourceVariantCache baseCache;
+
+ private GitResourceVariantCache theirsCache;
+
+ private GitResourceVariantCache oursCache;
+
+ private LinkedHashMap<IPath, IProject> map;
+
+ /**
+ * @param repository
+ * The repository this tree walk has been created for.
+ * @return
+ */
+ public Builder setRepository(Repository repository) {
+ this.repository = repository;
+ return this;
+ }
+
+ public Builder setaBaseTree(AbstractTreeIterator aBaseTree) {
+ this.aBaseTree = aBaseTree;
+ return this;
+ }
+
+ public Builder setHeadTree(RevTree headTree) {
+ this.headTree = headTree;
+ return this;
+ }
+
+ public Builder setMergeTree(RevTree mergeTree) {
+ this.mergeTree = mergeTree;
+ return this;
+ }
+
+ public Builder setDircache(DirCache dircache) {
+ this.dircache = dircache;
+ return this;
+ }
+
+ public Builder setReader(ObjectReader reader) {
+ this.reader = reader;
+ return this;
+ }
+
+ public TreeWalkResourceVariantTreeProvider build() throws IOException {
+
+ DirCacheBuilder aBuilder = dircache.builder();
+ DirCacheBuildIterator buildIt = new DirCacheBuildIterator(aBuilder);
+
+ this.map = new LinkedHashMap<>();
+
+ try (NameConflictTreeWalk treeWalk = new NameConflictTreeWalk(repository, reader)) {
+
+ int baseIndex = treeWalk.addTree(aBaseTree);
+ int ourIndex = treeWalk.addTree(headTree);
+ int theirIndex = treeWalk.addTree(mergeTree);
+ int dciPos = treeWalk.addTree(buildIt);
+ FileTreeIterator aWorkingTreeIterator = new FileTreeIterator(repository);
+ treeWalk.addTree(aWorkingTreeIterator);
+ aWorkingTreeIterator.setDirCacheIterator(treeWalk, dciPos);
+
+ this.baseCache = new GitResourceVariantCache();
+ this.theirsCache = new GitResourceVariantCache();
+ this.oursCache = new GitResourceVariantCache();
+
+ while (treeWalk.next()) {
+ final int modeBase = treeWalk.getRawMode(baseIndex);
+ final int modeOurs = treeWalk.getRawMode(ourIndex);
+ final int modeTheirs = treeWalk.getRawMode(theirIndex);
+ if (!hasSignificantDifference(modeBase, modeOurs, modeTheirs)) {
+ // conflict on file modes, leave the default merger handle it
+ continue;
+ }
+
+ final CanonicalTreeParser base = treeWalk.getTree(baseIndex, CanonicalTreeParser.class);
+ final CanonicalTreeParser ours = treeWalk.getTree(ourIndex, CanonicalTreeParser.class);
+ final CanonicalTreeParser theirs = treeWalk.getTree(theirIndex,
+ CanonicalTreeParser.class);
+
+ final int nonZeroMode = modeBase != 0 ? modeBase : modeOurs != 0 ? modeOurs : modeTheirs;
+ final IResource resource = getResourceHandleForLocation(repository,
+ treeWalk.getPathString(), FileMode.fromBits(nonZeroMode) == FileMode.TREE, map);
+
+ // Resource variants only make sense for IResources.
+ if (resource != null) {
+ IPath workspacePath = resource.getFullPath();
+ if (modeBase != 0) {
+ baseCache.setVariant(resource,
+ TreeParserResourceVariant.create(repository, base, workspacePath));
+ }
+ if (modeOurs != 0) {
+ oursCache.setVariant(resource,
+ TreeParserResourceVariant.create(repository, ours, workspacePath));
+ }
+ if (modeTheirs != 0) {
+ theirsCache.setVariant(resource,
+ TreeParserResourceVariant.create(repository, theirs, workspacePath));
+ }
+ }
+
+ if (treeWalk.isSubtree()) {
+ treeWalk.enterSubtree();
+ }
+ }
+
+ baseTree = new GitCachedResourceVariantTree(baseCache);
+ theirsTree = new GitCachedResourceVariantTree(theirsCache);
+ oursTree = new GitCachedResourceVariantTree(oursCache);
+
+ roots = new LinkedHashSet<>();
+ roots.addAll(baseCache.getRoots());
+ roots.addAll(oursCache.getRoots());
+ roots.addAll(theirsCache.getRoots());
+
+ knownResources = new LinkedHashSet<>();
+ knownResources.addAll(baseCache.getKnownResources());
+ knownResources.addAll(oursCache.getKnownResources());
+ knownResources.addAll(theirsCache.getKnownResources());
+ } finally {
+ // Needs reset since it might be used elsewhere
+ aBaseTree.reset();
+ }
+
+ return new TreeWalkResourceVariantTreeProvider(this);
+ }
+
+ private boolean hasSignificantDifference(int modeBase, int modeOurs, int modeTheirs) {
+ if (modeBase == 0) {
+ if (FileMode.fromBits(modeOurs | modeTheirs) != FileMode.MISSING) {
+ return true;
+ } else {
+ return (FileMode.fromBits(modeOurs) == FileMode.TREE
+ && FileMode.fromBits(modeTheirs) != FileMode.TREE)
+ || (FileMode.fromBits(modeOurs) != FileMode.TREE
+ && FileMode.fromBits(modeTheirs) == FileMode.TREE);
+ }
+ }
+ return FileMode.fromBits(modeBase & modeOurs) != FileMode.MISSING
+ || FileMode.fromBits(modeBase & modeTheirs) != FileMode.MISSING;
+ }
+
+ }
}
// CHECKSTYLE:ON
diff --git a/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/GitResourceVariantTreeSubscriberTest.java b/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/GitResourceVariantTreeSubscriberTest.java
index bc71ef8..e333a81 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/GitResourceVariantTreeSubscriberTest.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/GitResourceVariantTreeSubscriberTest.java
@@ -25,6 +25,7 @@
import org.eclipse.emf.compare.egit.internal.merge.TreeWalkResourceVariantTreeProvider;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.team.core.diff.IDiff;
@@ -249,10 +250,17 @@
RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
TreeWalk treeWalk = new NameConflictTreeWalk(repo);
- treeWalk.addTree(baseTree);
+ int baseTreeIteratorIndex = treeWalk.addTree(baseTree);
treeWalk.addTree(sourceTree);
treeWalk.addTree(remoteTree);
- return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
+ return new TreeWalkResourceVariantTreeProvider.Builder()//
+ .setRepository(repo)//
+ .setaBaseTree(treeWalk.getTree(baseTreeIteratorIndex, AbstractTreeIterator.class))//
+ .setHeadTree(sourceTree)//
+ .setMergeTree(remoteTree)//
+ .setDircache(repo.readDirCache())//
+ .setReader(repo.newObjectReader())//
+ .build();
} finally {
walk.close();
}
@@ -279,10 +287,17 @@
RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
TreeWalk treeWalk = new NameConflictTreeWalk(repo);
- treeWalk.addTree(baseTree);
+ int baseTreeIteratorIndex = treeWalk.addTree(baseTree);
treeWalk.addTree(sourceTree);
treeWalk.addTree(remoteTree);
- return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
+ return new TreeWalkResourceVariantTreeProvider.Builder()//
+ .setRepository(repo)//
+ .setaBaseTree(treeWalk.getTree(baseTreeIteratorIndex, AbstractTreeIterator.class))//
+ .setHeadTree(sourceTree)//
+ .setMergeTree(remoteTree)//
+ .setDircache(repo.readDirCache())//
+ .setReader(repo.newObjectReader())//
+ .build();
} finally {
walk.close();
}
@@ -314,10 +329,17 @@
RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
TreeWalk treeWalk = new NameConflictTreeWalk(repo);
- treeWalk.addTree(baseTree);
+ int baseTreeIteratorIndex = treeWalk.addTree(baseTree);
treeWalk.addTree(sourceTree);
treeWalk.addTree(remoteTree);
- return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
+ return new TreeWalkResourceVariantTreeProvider.Builder()//
+ .setRepository(repo)//
+ .setaBaseTree(treeWalk.getTree(baseTreeIteratorIndex, AbstractTreeIterator.class))//
+ .setHeadTree(sourceTree)//
+ .setMergeTree(remoteTree)//
+ .setDircache(repo.readDirCache())//
+ .setReader(repo.newObjectReader())//
+ .build();
} finally {
walk.close();
}
diff --git a/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/TreeWalkResourceVariantTreeProviderTest.java b/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/TreeWalkResourceVariantTreeProviderTest.java
index 25f8271..663dec9 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/TreeWalkResourceVariantTreeProviderTest.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/TreeWalkResourceVariantTreeProviderTest.java
@@ -20,6 +20,7 @@
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.team.core.variants.IResourceVariant;
@@ -57,11 +58,17 @@
RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
TreeWalk treeWalk = new NameConflictTreeWalk(repo);
- treeWalk.addTree(baseTree);
+ int baseTreeIndex = treeWalk.addTree(baseTree);
treeWalk.addTree(sourceTree);
treeWalk.addTree(remoteTree);
- TreeWalkResourceVariantTreeProvider treeProvider = new TreeWalkResourceVariantTreeProvider(repo,
- treeWalk, 0, 1, 2);
+ TreeWalkResourceVariantTreeProvider treeProvider = new TreeWalkResourceVariantTreeProvider.Builder()//
+ .setaBaseTree(treeWalk.getTree(baseTreeIndex, AbstractTreeIterator.class))//
+ .setDircache(repo.readDirCache())//
+ .setHeadTree(sourceTree)//
+ .setMergeTree(remoteTree)//
+ .setRepository(repo)//
+ .setReader(repo.newObjectReader())//
+ .build();
assertEquals(1, treeProvider.getRoots().size());
assertTrue(treeProvider.getRoots().contains(iProject));
