ResolveMerger.java
/*
* Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>,
* Copyright (C) 2010-2012, Matthias Sohn <matthias.sohn@sap.com>
* Copyright (C) 2012, Research In Motion Limited
* Copyright (C) 2017, Obeo (mathieu.cartaud@obeo.fr)
* Copyright (C) 2018, 2022 Thomas Wolf <twolf@apache.org>
* Copyright (C) 2022, Google Inc. and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.merge;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.time.Instant.EPOCH;
import static org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm.HISTOGRAM;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DIFF_SECTION;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_ALGORITHM;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import java.io.Closeable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.attributes.Attribute;
import org.eclipse.jgit.attributes.Attributes;
import org.eclipse.jgit.diff.DiffAlgorithm;
import org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
import org.eclipse.jgit.diff.RawText;
import org.eclipse.jgit.diff.RawTextComparator;
import org.eclipse.jgit.diff.Sequence;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuildIterator;
import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.dircache.DirCacheCheckout;
import org.eclipse.jgit.dircache.DirCacheCheckout.CheckoutMetadata;
import org.eclipse.jgit.dircache.DirCacheCheckout.StreamSupplier;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.errors.BinaryBlobException;
import org.eclipse.jgit.errors.IndexWriteException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.CoreConfig.EolStreamType;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.storage.pack.PackConfig;
import org.eclipse.jgit.submodule.SubmoduleConflict;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk.OperationType;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
import org.eclipse.jgit.treewalk.WorkingTreeOptions;
import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.LfsFactory;
import org.eclipse.jgit.util.LfsFactory.LfsInputStream;
import org.eclipse.jgit.util.TemporaryBuffer;
import org.eclipse.jgit.util.io.EolStreamTypeUtil;
/**
* A three-way merger performing a content-merge if necessary
*/
public class ResolveMerger extends ThreeWayMerger {
/**
* Handles work tree updates on both the checkout and the index.
* <p>
* You should use a single instance for all of your file changes. In case of
* an error, make sure your instance is released, and initiate a new one if
* necessary.
*
* @since 6.3.1
*/
protected static class WorkTreeUpdater implements Closeable {
/**
* The result of writing the index changes.
*/
public static class Result {
private final List<String> modifiedFiles = new LinkedList<>();
private final List<String> failedToDelete = new LinkedList<>();
private ObjectId treeId = null;
/**
* @return Modified tree ID if any, or null otherwise.
*/
public ObjectId getTreeId() {
return treeId;
}
/**
* @return Files that couldn't be deleted.
*/
public List<String> getFailedToDelete() {
return failedToDelete;
}
/**
* @return Files modified during this operation.
*/
public List<String> getModifiedFiles() {
return modifiedFiles;
}
}
Result result = new Result();
/**
* The repository this handler operates on.
*/
@Nullable
private final Repository repo;
/**
* Set to true if this operation should work in-memory. The repo's
* dircache and workingtree are not touched by this method. Eventually
* needed files are created as temporary files and a new empty,
* in-memory dircache will be used instead the repo's one. Often used
* for bare repos where the repo doesn't even have a workingtree and
* dircache.
*/
private final boolean inCore;
private final ObjectInserter inserter;
private final ObjectReader reader;
private DirCache dirCache;
private boolean implicitDirCache = false;
/**
* Builder to update the dir cache during this operation.
*/
private DirCacheBuilder builder;
/**
* The {@link WorkingTreeOptions} are needed to determine line endings
* for affected files.
*/
private WorkingTreeOptions workingTreeOptions;
/**
* The size limit (bytes) which controls a file to be stored in
* {@code Heap} or {@code LocalFile} during the operation.
*/
private int inCoreFileSizeLimit;
/**
* If the operation has nothing to do for a file but check it out at the
* end of the operation, it can be added here.
*/
private final Map<String, DirCacheEntry> toBeCheckedOut = new HashMap<>();
/**
* Files in this list will be deleted from the local copy at the end of
* the operation.
*/
private final TreeMap<String, File> toBeDeleted = new TreeMap<>();
/**
* Keeps {@link CheckoutMetadata} for {@link #checkout()}.
*/
private Map<String, CheckoutMetadata> checkoutMetadataByPath;
/**
* Keeps {@link CheckoutMetadata} for {@link #revertModifiedFiles()}.
*/
private Map<String, CheckoutMetadata> cleanupMetadataByPath;
/**
* Whether the changes were successfully written.
*/
private boolean indexChangesWritten;
/**
* @param repo
* the {@link Repository}.
* @param dirCache
* if set, use the provided dir cache. Otherwise, use the
* default repository one
*/
private WorkTreeUpdater(Repository repo, DirCache dirCache) {
this.repo = repo;
this.dirCache = dirCache;
this.inCore = false;
this.inserter = repo.newObjectInserter();
this.reader = inserter.newReader();
Config config = repo.getConfig();
this.workingTreeOptions = config.get(WorkingTreeOptions.KEY);
this.inCoreFileSizeLimit = getInCoreFileSizeLimit(config);
this.checkoutMetadataByPath = new HashMap<>();
this.cleanupMetadataByPath = new HashMap<>();
}
/**
* Creates a new {@link WorkTreeUpdater} for the given repository.
*
* @param repo
* the {@link Repository}.
* @param dirCache
* if set, use the provided dir cache. Otherwise, use the
* default repository one
* @return the {@link WorkTreeUpdater}.
*/
public static WorkTreeUpdater createWorkTreeUpdater(Repository repo,
DirCache dirCache) {
return new WorkTreeUpdater(repo, dirCache);
}
/**
* @param repo
* the {@link Repository}.
* @param dirCache
* if set, use the provided dir cache. Otherwise, creates a
* new one
* @param oi
* to use for writing the modified objects with.
*/
private WorkTreeUpdater(Repository repo, DirCache dirCache,
ObjectInserter oi) {
this.repo = repo;
this.dirCache = dirCache;
this.inserter = oi;
this.inCore = true;
this.reader = oi.newReader();
if (repo != null) {
this.inCoreFileSizeLimit = getInCoreFileSizeLimit(
repo.getConfig());
}
}
/**
* Creates a new {@link WorkTreeUpdater} that works in memory only.
*
* @param repo
* the {@link Repository}.
* @param dirCache
* if set, use the provided dir cache. Otherwise, creates a
* new one
* @param oi
* to use for writing the modified objects with.
* @return the {@link WorkTreeUpdater}
*/
public static WorkTreeUpdater createInCoreWorkTreeUpdater(
Repository repo, DirCache dirCache, ObjectInserter oi) {
return new WorkTreeUpdater(repo, dirCache, oi);
}
private static int getInCoreFileSizeLimit(Config config) {
return config.getInt(ConfigConstants.CONFIG_MERGE_SECTION,
ConfigConstants.CONFIG_KEY_IN_CORE_LIMIT, 10 << 20);
}
/**
* Gets the size limit for in-core files in this config.
*
* @return the size
*/
public int getInCoreFileSizeLimit() {
return inCoreFileSizeLimit;
}
/**
* Gets dir cache for the repo. Locked if not inCore.
*
* @return the result dir cache
* @throws IOException
* is case the dir cache cannot be read
*/
public DirCache getLockedDirCache() throws IOException {
if (dirCache == null) {
implicitDirCache = true;
if (inCore) {
dirCache = DirCache.newInCore();
} else {
dirCache = nonNullRepo().lockDirCache();
}
}
if (builder == null) {
builder = dirCache.builder();
}
return dirCache;
}
/**
* Creates a {@link DirCacheBuildIterator} for the builder of this
* {@link WorkTreeUpdater}.
*
* @return the {@link DirCacheBuildIterator}
*/
public DirCacheBuildIterator createDirCacheBuildIterator() {
return new DirCacheBuildIterator(builder);
}
/**
* Writes the changes to the working tree (but not to the index).
*
* @param shouldCheckoutTheirs
* before committing the changes
* @throws IOException
* if any of the writes fail
*/
public void writeWorkTreeChanges(boolean shouldCheckoutTheirs)
throws IOException {
handleDeletedFiles();
if (inCore) {
builder.finish();
return;
}
if (shouldCheckoutTheirs) {
// No problem found. The only thing left to be done is to
// check out all files from "theirs" which have been selected to
// go into the new index.
checkout();
}
// All content operations are successfully done. If we can now write
// the
// new index we are on quite safe ground. Even if the checkout of
// files coming from "theirs" fails the user can work around such
// failures by checking out the index again.
if (!builder.commit()) {
revertModifiedFiles();
throw new IndexWriteException();
}
}
/**
* Writes the changes to the index.
*
* @return the {@link Result} of the operation.
* @throws IOException
* if any of the writes fail
*/
public Result writeIndexChanges() throws IOException {
result.treeId = getLockedDirCache().writeTree(inserter);
indexChangesWritten = true;
return result;
}
/**
* Adds a {@link DirCacheEntry} for direct checkout and remembers its
* {@link CheckoutMetadata}.
*
* @param path
* of the entry
* @param entry
* to add
* @param cleanupStreamType
* to use for the cleanup metadata
* @param cleanupSmudgeCommand
* to use for the cleanup metadata
* @param checkoutStreamType
* to use for the checkout metadata
* @param checkoutSmudgeCommand
* to use for the checkout metadata
*/
public void addToCheckout(String path, DirCacheEntry entry,
EolStreamType cleanupStreamType, String cleanupSmudgeCommand,
EolStreamType checkoutStreamType,
String checkoutSmudgeCommand) {
if (entry != null) {
// In some cases, we just want to add the metadata.
toBeCheckedOut.put(path, entry);
}
addCheckoutMetadata(cleanupMetadataByPath, path, cleanupStreamType,
cleanupSmudgeCommand);
addCheckoutMetadata(checkoutMetadataByPath, path,
checkoutStreamType, checkoutSmudgeCommand);
}
/**
* Gets a map which maps the paths of files which have to be checked out
* because the operation created new fully-merged content for this file
* into the index.
* <p>
* This means: the operation wrote a new stage 0 entry for this path.
* </p>
*
* @return the map
*/
public Map<String, DirCacheEntry> getToBeCheckedOut() {
return toBeCheckedOut;
}
/**
* Remembers the given file to be deleted.
* <p>
* Note the actual deletion is only done in
* {@link #writeWorkTreeChanges}.
*
* @param path
* of the file to be deleted
* @param file
* to be deleted
* @param streamType
* to use for cleanup metadata
* @param smudgeCommand
* to use for cleanup metadata
*/
public void deleteFile(String path, File file, EolStreamType streamType,
String smudgeCommand) {
toBeDeleted.put(path, file);
if (file != null && file.isFile()) {
addCheckoutMetadata(cleanupMetadataByPath, path, streamType,
smudgeCommand);
}
}
/**
* Remembers the {@link CheckoutMetadata} for the given path; it may be
* needed in {@link #checkout()} or in {@link #revertModifiedFiles()}.
*
* @param map
* to add the metadata to
* @param path
* of the current node
* @param streamType
* to use for the metadata
* @param smudgeCommand
* to use for the metadata
*/
private void addCheckoutMetadata(Map<String, CheckoutMetadata> map,
String path, EolStreamType streamType, String smudgeCommand) {
if (inCore || map == null) {
return;
}
map.put(path, new CheckoutMetadata(streamType, smudgeCommand));
}
/**
* Detects if CRLF conversion has been configured.
* <p>
* </p>
* See {@link EolStreamTypeUtil#detectStreamType} for more info.
*
* @param attributes
* of the file for which the type is to be detected
* @return the detected type
*/
public EolStreamType detectCheckoutStreamType(Attributes attributes) {
if (inCore) {
return null;
}
return EolStreamTypeUtil.detectStreamType(OperationType.CHECKOUT_OP,
workingTreeOptions, attributes);
}
private void handleDeletedFiles() {
// Iterate in reverse so that "folder/file" is deleted before
// "folder". Otherwise, this could result in a failing path because
// of a non-empty directory, for which delete() would fail.
for (String path : toBeDeleted.descendingKeySet()) {
File file = inCore ? null : toBeDeleted.get(path);
if (file != null && !file.delete()) {
if (!file.isDirectory()) {
result.failedToDelete.add(path);
}
}
}
}
/**
* Marks the given path as modified in the operation.
*
* @param path
* to mark as modified
*/
public void markAsModified(String path) {
result.modifiedFiles.add(path);
}
/**
* Gets the list of files which were modified in this operation.
*
* @return the list
*/
public List<String> getModifiedFiles() {
return result.modifiedFiles;
}
private void checkout() throws NoWorkTreeException, IOException {
for (Map.Entry<String, DirCacheEntry> entry : toBeCheckedOut
.entrySet()) {
DirCacheEntry dirCacheEntry = entry.getValue();
if (dirCacheEntry.getFileMode() == FileMode.GITLINK) {
new File(nonNullRepo().getWorkTree(), entry.getKey())
.mkdirs();
} else {
DirCacheCheckout.checkoutEntry(repo, dirCacheEntry, reader,
false, checkoutMetadataByPath.get(entry.getKey()),
workingTreeOptions);
result.modifiedFiles.add(entry.getKey());
}
}
}
/**
* Reverts any uncommitted changes in the worktree. We know that for all
* modified files the old content was in the old index and the index
* contained only stage 0. In case of inCore operation just clear the
* history of modified files.
*
* @throws IOException
* in case the cleaning up failed
*/
public void revertModifiedFiles() throws IOException {
if (inCore) {
result.modifiedFiles.clear();
return;
}
if (indexChangesWritten) {
return;
}
for (String path : result.modifiedFiles) {
DirCacheEntry entry = dirCache.getEntry(path);
if (entry != null) {
DirCacheCheckout.checkoutEntry(repo, entry, reader, false,
cleanupMetadataByPath.get(path),
workingTreeOptions);
}
}
}
@Override
public void close() throws IOException {
if (implicitDirCache) {
dirCache.unlock();
}
}
/**
* Updates the file in the checkout with the given content.
*
* @param inputStream
* the content to be updated
* @param streamType
* for parsing the content
* @param smudgeCommand
* for formatting the content
* @param path
* of the file to be updated
* @param file
* to be updated
* @throws IOException
* if the file cannot be updated
*/
public void updateFileWithContent(StreamSupplier inputStream,
EolStreamType streamType, String smudgeCommand, String path,
File file) throws IOException {
if (inCore) {
return;
}
CheckoutMetadata metadata = new CheckoutMetadata(streamType,
smudgeCommand);
try (OutputStream outputStream = new FileOutputStream(file)) {
DirCacheCheckout.getContent(repo, path, metadata, inputStream,
workingTreeOptions, outputStream);
}
}
/**
* Creates a path with the given content, and adds it to the specified
* stage to the index builder.
*
* @param input
* the content to be updated
* @param path
* of the file to be updated
* @param fileMode
* of the modified file
* @param entryStage
* of the new entry
* @param lastModified
* instant of the modified file
* @param len
* of the content
* @param lfsAttribute
* for checking for LFS enablement
* @return the entry which was added to the index
* @throws IOException
* if inserting the content fails
*/
public DirCacheEntry insertToIndex(InputStream input, byte[] path,
FileMode fileMode, int entryStage, Instant lastModified,
int len, Attribute lfsAttribute) throws IOException {
return addExistingToIndex(insertResult(input, lfsAttribute, len),
path, fileMode, entryStage, lastModified, len);
}
/**
* Adds a path with the specified stage to the index builder.
*
* @param objectId
* of the existing object to add
* @param path
* of the modified file
* @param fileMode
* of the modified file
* @param entryStage
* of the new entry
* @param lastModified
* instant of the modified file
* @param len
* of the modified file content
* @return the entry which was added to the index
*/
public DirCacheEntry addExistingToIndex(ObjectId objectId, byte[] path,
FileMode fileMode, int entryStage, Instant lastModified,
int len) {
DirCacheEntry dce = new DirCacheEntry(path, entryStage);
dce.setFileMode(fileMode);
if (lastModified != null) {
dce.setLastModified(lastModified);
}
dce.setLength(inCore ? 0 : len);
dce.setObjectId(objectId);
builder.add(dce);
return dce;
}
private ObjectId insertResult(InputStream input, Attribute lfsAttribute,
long length) throws IOException {
try (LfsInputStream is = LfsFactory.getInstance()
.applyCleanFilter(repo, input, length, lfsAttribute)) {
return inserter.insert(OBJ_BLOB, is.getLength(), is);
}
}
/**
* Gets the non-null repository instance of this
* {@link WorkTreeUpdater}.
*
* @return non-null repository instance
* @throws NullPointerException
* if the handler was constructed without a repository.
*/
@NonNull
private Repository nonNullRepo() throws NullPointerException {
return Objects.requireNonNull(repo,
() -> JGitText.get().repositoryIsRequired);
}
}
/**
* If the merge fails (means: not stopped because of unresolved conflicts)
* this enum is used to explain why it failed
*/
public enum MergeFailureReason {
/** the merge failed because of a dirty index */
DIRTY_INDEX,
/** the merge failed because of a dirty workingtree */
DIRTY_WORKTREE,
/** the merge failed because of a file could not be deleted */
COULD_NOT_DELETE
}
/**
* The tree walk which we'll iterate over to merge entries.
*
* @since 3.4
*/
protected NameConflictTreeWalk tw;
/**
* string versions of a list of commit SHA1s
*
* @since 3.0
*/
protected String[] commitNames;
/**
* Index of the base tree within the {@link #tw tree walk}.
*
* @since 3.4
*/
protected static final int T_BASE = 0;
/**
* Index of our tree in withthe {@link #tw tree walk}.
*
* @since 3.4
*/
protected static final int T_OURS = 1;
/**
* Index of their tree within the {@link #tw tree walk}.
*
* @since 3.4
*/
protected static final int T_THEIRS = 2;
/**
* Index of the index tree within the {@link #tw tree walk}.
*
* @since 3.4
*/
protected static final int T_INDEX = 3;
/**
* Index of the working directory tree within the {@link #tw tree walk}.
*
* @since 3.4
*/
protected static final int T_FILE = 4;
/**
* Handler for repository I/O actions.
*
* @since 6.3
*/
protected WorkTreeUpdater workTreeUpdater;
/**
* merge result as tree
*
* @since 3.0
*/
protected ObjectId resultTree;
/**
* Files modified during this operation. Note this list is only updated after a successful write.
*/
protected List<String> modifiedFiles = new ArrayList<>();
/**
* Paths that could not be merged by this merger because of an unsolvable
* conflict.
*
* @since 3.4
*/
protected List<String> unmergedPaths = new ArrayList<>();
/**
* Low-level textual merge results. Will be passed on to the callers in case
* of conflicts.
*
* @since 3.4
*/
protected Map<String, MergeResult<? extends Sequence>> mergeResults = new HashMap<>();
/**
* Paths for which the merge failed altogether.
*
* @since 3.4
*/
protected Map<String, MergeFailureReason> failingPaths = new HashMap<>();
/**
* Updated as we merge entries of the tree walk. Tells us whether we should
* recurse into the entry if it is a subtree.
*
* @since 3.4
*/
protected boolean enterSubtree;
/**
* Set to true if this merge should work in-memory. The repos dircache and
* workingtree are not touched by this method. Eventually needed files are
* created as temporary files and a new empty, in-memory dircache will be
* used instead the repo's one. Often used for bare repos where the repo
* doesn't even have a workingtree and dircache.
* @since 3.0
*/
protected boolean inCore;
/**
* Directory cache
* @since 3.0
*/
protected DirCache dircache;
/**
* The iterator to access the working tree. If set to <code>null</code> this
* merger will not touch the working tree.
* @since 3.0
*/
protected WorkingTreeIterator workingTreeIterator;
/**
* our merge algorithm
* @since 3.0
*/
protected MergeAlgorithm mergeAlgorithm;
/**
* The {@link ContentMergeStrategy} to use for "resolve" and "recursive"
* merges.
*/
@NonNull
private ContentMergeStrategy contentStrategy = ContentMergeStrategy.CONFLICT;
private static MergeAlgorithm getMergeAlgorithm(Config config) {
SupportedAlgorithm diffAlg = config.getEnum(
CONFIG_DIFF_SECTION, null, CONFIG_KEY_ALGORITHM,
HISTOGRAM);
return new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
}
private static String[] defaultCommitNames() {
return new String[]{"BASE", "OURS", "THEIRS"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
private static final Attributes NO_ATTRIBUTES = new Attributes();
/**
* Constructor for ResolveMerger.
*
* @param local
* the {@link org.eclipse.jgit.lib.Repository}.
* @param inCore
* a boolean.
*/
protected ResolveMerger(Repository local, boolean inCore) {
super(local);
Config config = local.getConfig();
mergeAlgorithm = getMergeAlgorithm(config);
commitNames = defaultCommitNames();
this.inCore = inCore;
}
/**
* Constructor for ResolveMerger.
*
* @param local
* the {@link org.eclipse.jgit.lib.Repository}.
*/
protected ResolveMerger(Repository local) {
this(local, false);
}
/**
* Constructor for ResolveMerger.
*
* @param inserter
* an {@link org.eclipse.jgit.lib.ObjectInserter} object.
* @param config
* the repository configuration
* @since 4.8
*/
protected ResolveMerger(ObjectInserter inserter, Config config) {
super(inserter);
mergeAlgorithm = getMergeAlgorithm(config);
commitNames = defaultCommitNames();
inCore = true;
}
/**
* Retrieves the content merge strategy for content conflicts.
*
* @return the {@link ContentMergeStrategy} in effect
* @since 5.12
*/
@NonNull
public ContentMergeStrategy getContentMergeStrategy() {
return contentStrategy;
}
/**
* Sets the content merge strategy for content conflicts.
*
* @param strategy
* {@link ContentMergeStrategy} to use
* @since 5.12
*/
public void setContentMergeStrategy(ContentMergeStrategy strategy) {
contentStrategy = strategy == null ? ContentMergeStrategy.CONFLICT
: strategy;
}
/** {@inheritDoc} */
@Override
protected boolean mergeImpl() throws IOException {
return mergeTrees(mergeBase(), sourceTrees[0], sourceTrees[1],
false);
}
/**
* adds a new path with the specified stage to the index builder
*
* @param path
* @param p
* @param stage
* @param lastMod
* @param len
* @return the entry which was added to the index
*/
private DirCacheEntry add(byte[] path, CanonicalTreeParser p, int stage,
Instant lastMod, long len) {
if (p != null && !p.getEntryFileMode().equals(FileMode.TREE)) {
return workTreeUpdater.addExistingToIndex(p.getEntryObjectId(), path,
p.getEntryFileMode(), stage,
lastMod, (int) len);
}
return null;
}
/**
* Adds the conflict stages for the current path of {@link #tw} to the index
* builder and returns the "theirs" stage; if present.
*
* @param base
* of the conflict
* @param ours
* of the conflict
* @param theirs
* of the conflict
* @return the {@link DirCacheEntry} for the "theirs" stage, or {@code null}
*/
private DirCacheEntry addConflict(CanonicalTreeParser base,
CanonicalTreeParser ours, CanonicalTreeParser theirs) {
add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
return add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
}
/**
* adds a entry to the index builder which is a copy of the specified
* DirCacheEntry
*
* @param e
* the entry which should be copied
*
* @return the entry which was added to the index
*/
private DirCacheEntry keep(DirCacheEntry e) {
return workTreeUpdater.addExistingToIndex(e.getObjectId(), e.getRawPath(), e.getFileMode(),
e.getStage(), e.getLastModifiedInstant(), e.getLength());
}
/**
* Adds a {@link DirCacheEntry} for direct checkout and remembers its
* {@link CheckoutMetadata}.
*
* @param path
* of the entry
* @param entry
* to add
* @param attributes
* the {@link Attributes} of the trees
* @throws IOException
* if the {@link CheckoutMetadata} cannot be determined
* @since 6.1
*/
protected void addToCheckout(String path, DirCacheEntry entry,
Attributes[] attributes)
throws IOException {
EolStreamType cleanupStreamType = workTreeUpdater.detectCheckoutStreamType(attributes[T_OURS]);
String cleanupSmudgeCommand = tw.getSmudgeCommand(attributes[T_OURS]);
EolStreamType checkoutStreamType = workTreeUpdater.detectCheckoutStreamType(attributes[T_THEIRS]);
String checkoutSmudgeCommand = tw.getSmudgeCommand(attributes[T_THEIRS]);
workTreeUpdater.addToCheckout(path, entry, cleanupStreamType, cleanupSmudgeCommand,
checkoutStreamType, checkoutSmudgeCommand);
}
/**
* Remember a path for deletion, and remember its {@link CheckoutMetadata}
* in case it has to be restored in the cleanUp.
*
* @param path
* of the entry
* @param isFile
* whether it is a file
* @param attributes
* to use for determining the {@link CheckoutMetadata}
* @throws IOException
* if the {@link CheckoutMetadata} cannot be determined
* @since 5.1
*/
protected void addDeletion(String path, boolean isFile,
Attributes attributes) throws IOException {
if (db == null || nonNullRepo().isBare() || !isFile)
return;
File file = new File(nonNullRepo().getWorkTree(), path);
EolStreamType streamType = workTreeUpdater.detectCheckoutStreamType(attributes);
String smudgeCommand = tw.getSmudgeCommand(attributes);
workTreeUpdater.deleteFile(path, file, streamType, smudgeCommand);
}
/**
* Processes one path and tries to merge taking git attributes in account.
* This method will do all trivial (not content) merges and will also detect
* if a merge will fail. The merge will fail when one of the following is
* true
* <ul>
* <li>the index entry does not match the entry in ours. When merging one
* branch into the current HEAD, ours will point to HEAD and theirs will
* point to the other branch. It is assumed that the index matches the HEAD
* because it will only not match HEAD if it was populated before the merge
* operation. But the merge commit should not accidentally contain
* modifications done before the merge. Check the <a href=
* "http://www.kernel.org/pub/software/scm/git/docs/git-read-tree.html#_3_way_merge"
* >git read-tree</a> documentation for further explanations.</li>
* <li>A conflict was detected and the working-tree file is dirty. When a
* conflict is detected the content-merge algorithm will try to write a
* merged version into the working-tree. If the file is dirty we would
* override unsaved data.</li>
* </ul>
*
* @param base
* the common base for ours and theirs
* @param ours
* the ours side of the merge. When merging a branch into the
* HEAD ours will point to HEAD
* @param theirs
* the theirs side of the merge. When merging a branch into the
* current HEAD theirs will point to the branch which is merged
* into HEAD.
* @param index
* the index entry
* @param work
* the file in the working tree
* @param ignoreConflicts
* see
* {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
* @param attributes
* the {@link Attributes} for the three trees
* @return <code>false</code> if the merge will fail because the index entry
* didn't match ours or the working-dir file was dirty and a
* conflict occurred
* @throws java.io.IOException
* @since 6.1
*/
protected boolean processEntry(CanonicalTreeParser base,
CanonicalTreeParser ours, CanonicalTreeParser theirs,
DirCacheBuildIterator index, WorkingTreeIterator work,
boolean ignoreConflicts, Attributes[] attributes)
throws IOException {
enterSubtree = true;
final int modeO = tw.getRawMode(T_OURS);
final int modeT = tw.getRawMode(T_THEIRS);
final int modeB = tw.getRawMode(T_BASE);
boolean gitLinkMerging = isGitLink(modeO) || isGitLink(modeT)
|| isGitLink(modeB);
if (modeO == 0 && modeT == 0 && modeB == 0) {
// File is either untracked or new, staged but uncommitted
return true;
}
if (isIndexDirty()) {
return false;
}
DirCacheEntry ourDce = null;
if (index == null || index.getDirCacheEntry() == null) {
// create a fake DCE, but only if ours is valid. ours is kept only
// in case it is valid, so a null ourDce is ok in all other cases.
if (nonTree(modeO)) {
ourDce = new DirCacheEntry(tw.getRawPath());
ourDce.setObjectId(tw.getObjectId(T_OURS));
ourDce.setFileMode(tw.getFileMode(T_OURS));
}
} else {
ourDce = index.getDirCacheEntry();
}
if (nonTree(modeO) && nonTree(modeT) && tw.idEqual(T_OURS, T_THEIRS)) {
// OURS and THEIRS have equal content. Check the file mode
if (modeO == modeT) {
// content and mode of OURS and THEIRS are equal: it doesn't
// matter which one we choose. OURS is chosen. Since the index
// is clean (the index matches already OURS) we can keep the existing one
keep(ourDce);
// no checkout needed!
return true;
}
// same content but different mode on OURS and THEIRS.
// Try to merge the mode and report an error if this is
// not possible.
int newMode = mergeFileModes(modeB, modeO, modeT);
if (newMode != FileMode.MISSING.getBits()) {
if (newMode == modeO) {
// ours version is preferred
keep(ourDce);
} else {
// the preferred version THEIRS has a different mode
// than ours. Check it out!
if (isWorktreeDirty(work, ourDce)) {
return false;
}
// we know about length and lastMod only after we have
// written the new content.
// This will happen later. Set these values to 0 for know.
DirCacheEntry e = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
addToCheckout(tw.getPathString(), e, attributes);
}
return true;
}
if (!ignoreConflicts) {
// FileModes are not mergeable. We found a conflict on modes.
// For conflicting entries we don't know lastModified and
// length.
// This path can be skipped on ignoreConflicts, so the caller
// could use virtual commit.
addConflict(base, ours, theirs);
unmergedPaths.add(tw.getPathString());
mergeResults.put(tw.getPathString(),
new MergeResult<>(Collections.emptyList()));
}
return true;
}
if (modeB == modeT && tw.idEqual(T_BASE, T_THEIRS)) {
// THEIRS was not changed compared to BASE. All changes must be in
// OURS. OURS is chosen. We can keep the existing entry.
if (ourDce != null) {
keep(ourDce);
}
// no checkout needed!
return true;
}
if (modeB == modeO && tw.idEqual(T_BASE, T_OURS)) {
// OURS was not changed compared to BASE. All changes must be in
// THEIRS. THEIRS is chosen.
// Check worktree before checking out THEIRS
if (isWorktreeDirty(work, ourDce)) {
return false;
}
if (nonTree(modeT)) {
// we know about length and lastMod only after we have written
// the new content.
// This will happen later. Set these values to 0 for know.
DirCacheEntry e = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
if (e != null) {
addToCheckout(tw.getPathString(), e, attributes);
}
return true;
}
// we want THEIRS ... but THEIRS contains a folder or the
// deletion of the path. Delete what's in the working tree,
// which we know to be clean.
if (tw.getTreeCount() > T_FILE && tw.getRawMode(T_FILE) == 0) {
// Not present in working tree, so nothing to delete
return true;
}
if (modeT != 0 && modeT == modeB) {
// Base, ours, and theirs all contain a folder: don't delete
return true;
}
addDeletion(tw.getPathString(), nonTree(modeO), attributes[T_OURS]);
return true;
}
if (tw.isSubtree()) {
// file/folder conflicts: here I want to detect only file/folder
// conflict between ours and theirs. file/folder conflicts between
// base/index/workingTree and something else are not relevant or
// detected later
if (nonTree(modeO) != nonTree(modeT)) {
if (ignoreConflicts) {
// In case of merge failures, ignore this path instead of reporting unmerged, so
// a caller can use virtual commit. This will not result in files with conflict
// markers in the index/working tree. The actual diff on the path will be
// computed directly on children.
enterSubtree = false;
return true;
}
if (nonTree(modeB)) {
add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
}
if (nonTree(modeO)) {
add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
}
if (nonTree(modeT)) {
add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
}
unmergedPaths.add(tw.getPathString());
enterSubtree = false;
return true;
}
// ours and theirs are both folders or both files (and treewalk
// tells us we are in a subtree because of index or working-dir).
// If they are both folders no content-merge is required - we can
// return here.
if (!nonTree(modeO)) {
return true;
}
// ours and theirs are both files, just fall out of the if block
// and do the content merge
}
if (nonTree(modeO) && nonTree(modeT)) {
// Check worktree before modifying files
boolean worktreeDirty = isWorktreeDirty(work, ourDce);
if (!attributes[T_OURS].canBeContentMerged() && worktreeDirty) {
return false;
}
if (gitLinkMerging && ignoreConflicts) {
// Always select 'ours' in case of GITLINK merge failures so
// a caller can use virtual commit.
add(tw.getRawPath(), ours, DirCacheEntry.STAGE_0, EPOCH, 0);
return true;
} else if (gitLinkMerging) {
addConflict(base, ours, theirs);
MergeResult<SubmoduleConflict> result = createGitLinksMergeResult(
base, ours, theirs);
result.setContainsConflicts(true);
mergeResults.put(tw.getPathString(), result);
unmergedPaths.add(tw.getPathString());
return true;
} else if (!attributes[T_OURS].canBeContentMerged()) {
// File marked as binary
switch (getContentMergeStrategy()) {
case OURS:
keep(ourDce);
return true;
case THEIRS:
DirCacheEntry theirEntry = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
addToCheckout(tw.getPathString(), theirEntry, attributes);
return true;
default:
break;
}
addConflict(base, ours, theirs);
// attribute merge issues are conflicts but not failures
unmergedPaths.add(tw.getPathString());
return true;
}
// Check worktree before modifying files
if (worktreeDirty) {
return false;
}
MergeResult<RawText> result = null;
boolean hasSymlink = FileMode.SYMLINK.equals(modeO)
|| FileMode.SYMLINK.equals(modeT);
if (!hasSymlink) {
try {
result = contentMerge(base, ours, theirs, attributes,
getContentMergeStrategy());
} catch (BinaryBlobException e) {
// result == null
}
}
if (result == null) {
switch (getContentMergeStrategy()) {
case OURS:
keep(ourDce);
return true;
case THEIRS:
DirCacheEntry e = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
if (e != null) {
addToCheckout(tw.getPathString(), e, attributes);
}
return true;
default:
result = new MergeResult<>(Collections.emptyList());
result.setContainsConflicts(true);
break;
}
}
if (ignoreConflicts) {
result.setContainsConflicts(false);
}
String currentPath = tw.getPathString();
if (hasSymlink) {
if (ignoreConflicts) {
if (((modeT & FileMode.TYPE_MASK) == FileMode.TYPE_FILE)) {
DirCacheEntry e = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
addToCheckout(currentPath, e, attributes);
} else {
keep(ourDce);
}
} else {
// Record the conflict
DirCacheEntry e = addConflict(base, ours, theirs);
mergeResults.put(currentPath, result);
// If theirs is a file, check it out. In link/file
// conflicts, C git prefers the file.
if (((modeT & FileMode.TYPE_MASK) == FileMode.TYPE_FILE)
&& e != null) {
addToCheckout(currentPath, e, attributes);
}
}
} else {
updateIndex(base, ours, theirs, result, attributes[T_OURS]);
}
if (result.containsConflicts() && !ignoreConflicts) {
unmergedPaths.add(currentPath);
}
workTreeUpdater.markAsModified(currentPath);
// Entry is null - only adds the metadata.
addToCheckout(currentPath, null, attributes);
} else if (modeO != modeT) {
// OURS or THEIRS has been deleted
if (((modeO != 0 && !tw.idEqual(T_BASE, T_OURS)) || (modeT != 0 && !tw
.idEqual(T_BASE, T_THEIRS)))) {
if (gitLinkMerging && ignoreConflicts) {
add(tw.getRawPath(), ours, DirCacheEntry.STAGE_0, EPOCH, 0);
} else if (gitLinkMerging) {
addConflict(base, ours, theirs);
MergeResult<SubmoduleConflict> result = createGitLinksMergeResult(
base, ours, theirs);
result.setContainsConflicts(true);
mergeResults.put(tw.getPathString(), result);
unmergedPaths.add(tw.getPathString());
} else {
boolean isSymLink = ((modeO | modeT)
& FileMode.TYPE_MASK) == FileMode.TYPE_SYMLINK;
// Content merge strategy does not apply to delete-modify
// conflicts!
MergeResult<RawText> result;
if (isSymLink) {
// No need to do a content merge
result = new MergeResult<>(Collections.emptyList());
result.setContainsConflicts(true);
} else {
try {
result = contentMerge(base, ours, theirs,
attributes, ContentMergeStrategy.CONFLICT);
} catch (BinaryBlobException e) {
result = new MergeResult<>(Collections.emptyList());
result.setContainsConflicts(true);
}
}
if (ignoreConflicts) {
result.setContainsConflicts(false);
if (isSymLink) {
if (modeO != 0) {
keep(ourDce);
} else {
// Check out theirs
if (isWorktreeDirty(work, ourDce)) {
return false;
}
DirCacheEntry e = add(tw.getRawPath(), theirs,
DirCacheEntry.STAGE_0, EPOCH, 0);
if (e != null) {
addToCheckout(tw.getPathString(), e,
attributes);
}
}
} else {
// In case a conflict is detected the working tree
// file is again filled with new content (containing
// conflict markers). But also stage 0 of the index
// is filled with that content.
updateIndex(base, ours, theirs, result,
attributes[T_OURS]);
}
} else {
DirCacheEntry e = addConflict(base, ours, theirs);
// OURS was deleted checkout THEIRS
if (modeO == 0) {
// Check worktree before checking out THEIRS
if (isWorktreeDirty(work, ourDce)) {
return false;
}
if (nonTree(modeT) && e != null) {
addToCheckout(tw.getPathString(), e,
attributes);
}
}
unmergedPaths.add(tw.getPathString());
// generate a MergeResult for the deleted file
mergeResults.put(tw.getPathString(), result);
}
}
}
}
return true;
}
private static MergeResult<SubmoduleConflict> createGitLinksMergeResult(
CanonicalTreeParser base, CanonicalTreeParser ours,
CanonicalTreeParser theirs) {
return new MergeResult<>(Arrays.asList(
new SubmoduleConflict(
base == null ? null : base.getEntryObjectId()),
new SubmoduleConflict(
ours == null ? null : ours.getEntryObjectId()),
new SubmoduleConflict(
theirs == null ? null : theirs.getEntryObjectId())));
}
/**
* Does the content merge. The three texts base, ours and theirs are
* specified with {@link CanonicalTreeParser}. If any of the parsers is
* specified as <code>null</code> then an empty text will be used instead.
*
* @param base
* @param ours
* @param theirs
* @param attributes
* @param strategy
*
* @return the result of the content merge
* @throws BinaryBlobException
* if any of the blobs looks like a binary blob
* @throws IOException
*/
private MergeResult<RawText> contentMerge(CanonicalTreeParser base,
CanonicalTreeParser ours, CanonicalTreeParser theirs,
Attributes[] attributes, ContentMergeStrategy strategy)
throws BinaryBlobException, IOException {
// TW: The attributes here are used to determine the LFS smudge filter.
// Is doing a content merge on LFS items really a good idea??
RawText baseText = base == null ? RawText.EMPTY_TEXT
: getRawText(base.getEntryObjectId(), attributes[T_BASE]);
RawText ourText = ours == null ? RawText.EMPTY_TEXT
: getRawText(ours.getEntryObjectId(), attributes[T_OURS]);
RawText theirsText = theirs == null ? RawText.EMPTY_TEXT
: getRawText(theirs.getEntryObjectId(), attributes[T_THEIRS]);
mergeAlgorithm.setContentMergeStrategy(strategy);
return mergeAlgorithm.merge(RawTextComparator.DEFAULT, baseText,
ourText, theirsText);
}
private boolean isIndexDirty() {
if (inCore) {
return false;
}
final int modeI = tw.getRawMode(T_INDEX);
final int modeO = tw.getRawMode(T_OURS);
// Index entry has to match ours to be considered clean
final boolean isDirty = nonTree(modeI)
&& !(modeO == modeI && tw.idEqual(T_INDEX, T_OURS));
if (isDirty) {
failingPaths
.put(tw.getPathString(), MergeFailureReason.DIRTY_INDEX);
}
return isDirty;
}
private boolean isWorktreeDirty(WorkingTreeIterator work,
DirCacheEntry ourDce) throws IOException {
if (work == null) {
return false;
}
final int modeF = tw.getRawMode(T_FILE);
final int modeO = tw.getRawMode(T_OURS);
// Worktree entry has to match ours to be considered clean
boolean isDirty;
if (ourDce != null) {
isDirty = work.isModified(ourDce, true, reader);
} else {
isDirty = work.isModeDifferent(modeO);
if (!isDirty && nonTree(modeF)) {
isDirty = !tw.idEqual(T_FILE, T_OURS);
}
}
// Ignore existing empty directories
if (isDirty && modeF == FileMode.TYPE_TREE
&& modeO == FileMode.TYPE_MISSING) {
isDirty = false;
}
if (isDirty) {
failingPaths.put(tw.getPathString(),
MergeFailureReason.DIRTY_WORKTREE);
}
return isDirty;
}
/**
* Updates the index after a content merge has happened. If no conflict has
* occurred this includes persisting the merged content to the object
* database. In case of conflicts this method takes care to write the
* correct stages to the index.
*
* @param base
* @param ours
* @param theirs
* @param result
* @param attributes
* @throws IOException
*/
private void updateIndex(CanonicalTreeParser base,
CanonicalTreeParser ours, CanonicalTreeParser theirs,
MergeResult<RawText> result, Attributes attributes)
throws IOException {
TemporaryBuffer rawMerged = null;
try {
rawMerged = doMerge(result);
File mergedFile = inCore ? null
: writeMergedFile(rawMerged, attributes);
if (result.containsConflicts()) {
// A conflict occurred, the file will contain conflict markers
// the index will be populated with the three stages and the
// workdir (if used) contains the halfway merged content.
addConflict(base, ours, theirs);
mergeResults.put(tw.getPathString(), result);
return;
}
// No conflict occurred, the file will contain fully merged content.
// The index will be populated with the new merged version.
Instant lastModified = mergedFile == null ? null
: nonNullRepo().getFS().lastModifiedInstant(mergedFile);
// Set the mode for the new content. Fall back to REGULAR_FILE if
// we can't merge modes of OURS and THEIRS.
int newMode = mergeFileModes(tw.getRawMode(0), tw.getRawMode(1),
tw.getRawMode(2));
FileMode mode = newMode == FileMode.MISSING.getBits()
? FileMode.REGULAR_FILE : FileMode.fromBits(newMode);
workTreeUpdater.insertToIndex(rawMerged.openInputStream(),
tw.getPathString().getBytes(UTF_8), mode,
DirCacheEntry.STAGE_0, lastModified,
(int) rawMerged.length(),
attributes.get(Constants.ATTR_MERGE));
} finally {
if (rawMerged != null) {
rawMerged.destroy();
}
}
}
/**
* Writes merged file content to the working tree.
*
* @param rawMerged
* the raw merged content
* @param attributes
* the files .gitattributes entries
* @return the working tree file to which the merged content was written.
* @throws IOException
*/
private File writeMergedFile(TemporaryBuffer rawMerged,
Attributes attributes)
throws IOException {
File workTree = nonNullRepo().getWorkTree();
FS fs = nonNullRepo().getFS();
File of = new File(workTree, tw.getPathString());
File parentFolder = of.getParentFile();
EolStreamType eol = workTreeUpdater.detectCheckoutStreamType(attributes);
if (!fs.exists(parentFolder)) {
parentFolder.mkdirs();
}
workTreeUpdater.updateFileWithContent(rawMerged::openInputStream,
eol, tw.getSmudgeCommand(attributes), of.getPath(), of);
return of;
}
private TemporaryBuffer doMerge(MergeResult<RawText> result)
throws IOException {
TemporaryBuffer.LocalFile buf = new TemporaryBuffer.LocalFile(
db != null ? nonNullRepo().getDirectory() : null, workTreeUpdater.getInCoreFileSizeLimit());
boolean success = false;
try {
new MergeFormatter().formatMerge(buf, result,
Arrays.asList(commitNames), UTF_8);
buf.close();
success = true;
} finally {
if (!success) {
buf.destroy();
}
}
return buf;
}
/**
* Try to merge filemodes. If only ours or theirs have changed the mode
* (compared to base) we choose that one. If ours and theirs have equal
* modes return that one. If also that is not the case the modes are not
* mergeable. Return {@link FileMode#MISSING} int that case.
*
* @param modeB
* filemode found in BASE
* @param modeO
* filemode found in OURS
* @param modeT
* filemode found in THEIRS
*
* @return the merged filemode or {@link FileMode#MISSING} in case of a
* conflict
*/
private int mergeFileModes(int modeB, int modeO, int modeT) {
if (modeO == modeT) {
return modeO;
}
if (modeB == modeO) {
// Base equal to Ours -> chooses Theirs if that is not missing
return (modeT == FileMode.MISSING.getBits()) ? modeO : modeT;
}
if (modeB == modeT) {
// Base equal to Theirs -> chooses Ours if that is not missing
return (modeO == FileMode.MISSING.getBits()) ? modeT : modeO;
}
return FileMode.MISSING.getBits();
}
private RawText getRawText(ObjectId id,
Attributes attributes)
throws IOException, BinaryBlobException {
if (id.equals(ObjectId.zeroId())) {
return new RawText(new byte[]{});
}
ObjectLoader loader = LfsFactory.getInstance().applySmudgeFilter(
getRepository(), reader.open(id, OBJ_BLOB),
attributes.get(Constants.ATTR_MERGE));
int threshold = PackConfig.DEFAULT_BIG_FILE_THRESHOLD;
return RawText.load(loader, threshold);
}
private static boolean nonTree(int mode) {
return mode != 0 && !FileMode.TREE.equals(mode);
}
private static boolean isGitLink(int mode) {
return FileMode.GITLINK.equals(mode);
}
/** {@inheritDoc} */
@Override
public ObjectId getResultTreeId() {
return (resultTree == null) ? null : resultTree.toObjectId();
}
/**
* Set the names of the commits as they would appear in conflict markers
*
* @param commitNames
* the names of the commits as they would appear in conflict
* markers
*/
public void setCommitNames(String[] commitNames) {
this.commitNames = commitNames;
}
/**
* Get the names of the commits as they would appear in conflict markers.
*
* @return the names of the commits as they would appear in conflict
* markers.
*/
public String[] getCommitNames() {
return commitNames;
}
/**
* Get the paths with conflicts. This is a subset of the files listed by
* {@link #getModifiedFiles()}
*
* @return the paths with conflicts. This is a subset of the files listed by
* {@link #getModifiedFiles()}
*/
public List<String> getUnmergedPaths() {
return unmergedPaths;
}
/**
* Get the paths of files which have been modified by this merge.
*
* @return the paths of files which have been modified by this merge. A file
* will be modified if a content-merge works on this path or if the
* merge algorithm decides to take the theirs-version. This is a
* superset of the files listed by {@link #getUnmergedPaths()}.
*/
public List<String> getModifiedFiles() {
return workTreeUpdater != null ? workTreeUpdater.getModifiedFiles() : modifiedFiles;
}
/**
* Get a map which maps the paths of files which have to be checked out
* because the merge created new fully-merged content for this file into the
* index.
*
* @return a map which maps the paths of files which have to be checked out
* because the merge created new fully-merged content for this file
* into the index. This means: the merge wrote a new stage 0 entry
* for this path.
*/
public Map<String, DirCacheEntry> getToBeCheckedOut() {
return workTreeUpdater.getToBeCheckedOut();
}
/**
* Get the mergeResults
*
* @return the mergeResults
*/
public Map<String, MergeResult<? extends Sequence>> getMergeResults() {
return mergeResults;
}
/**
* Get list of paths causing this merge to fail (not stopped because of a
* conflict).
*
* @return lists paths causing this merge to fail (not stopped because of a
* conflict). <code>null</code> is returned if this merge didn't
* fail.
*/
public Map<String, MergeFailureReason> getFailingPaths() {
return failingPaths.isEmpty() ? null : failingPaths;
}
/**
* Returns whether this merge failed (i.e. not stopped because of a
* conflict)
*
* @return <code>true</code> if a failure occurred, <code>false</code>
* otherwise
*/
public boolean failed() {
return !failingPaths.isEmpty();
}
/**
* Sets the DirCache which shall be used by this merger. If the DirCache is
* not set explicitly and if this merger doesn't work in-core, this merger
* will implicitly get and lock a default DirCache. If the DirCache is
* explicitly set the caller is responsible to lock it in advance. Finally
* the merger will call {@link org.eclipse.jgit.dircache.DirCache#commit()}
* which requires that the DirCache is locked. If the {@link #mergeImpl()}
* returns without throwing an exception the lock will be released. In case
* of exceptions the caller is responsible to release the lock.
*
* @param dc
* the DirCache to set
*/
public void setDirCache(DirCache dc) {
this.dircache = dc;
}
/**
* Sets the WorkingTreeIterator to be used by this merger. If no
* WorkingTreeIterator is set this merger will ignore the working tree and
* fail if a content merge is necessary.
* <p>
* TODO: enhance WorkingTreeIterator to support write operations. Then this
* merger will be able to merge with a different working tree abstraction.
*
* @param workingTreeIterator
* the workingTreeIt to set
*/
public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
this.workingTreeIterator = workingTreeIterator;
}
/**
* The resolve conflict way of three way merging
*
* @param baseTree
* a {@link org.eclipse.jgit.treewalk.AbstractTreeIterator}
* object.
* @param headTree
* a {@link org.eclipse.jgit.revwalk.RevTree} object.
* @param mergeTree
* a {@link org.eclipse.jgit.revwalk.RevTree} object.
* @param ignoreConflicts
* Controls what to do in case a content-merge is done and a
* conflict is detected. The default setting for this should be
* <code>false</code>. In this case the working tree file is
* filled with new content (containing conflict markers) and the
* index is filled with multiple stages containing BASE, OURS and
* THEIRS content. Having such non-0 stages is the sign to git
* tools that there are still conflicts for that path.
* <p>
* If <code>true</code> is specified the behavior is different.
* In case a conflict is detected the working tree file is again
* filled with new content (containing conflict markers). But
* also stage 0 of the index is filled with that content. No
* other stages are filled. Means: there is no conflict on that
* path but the new content (including conflict markers) is
* stored as successful merge result. This is needed in the
* context of {@link org.eclipse.jgit.merge.RecursiveMerger}
* where when determining merge bases we don't want to deal with
* content-merge conflicts.
* @return whether the trees merged cleanly
* @throws java.io.IOException
* @since 3.5
*/
protected boolean mergeTrees(AbstractTreeIterator baseTree,
RevTree headTree, RevTree mergeTree, boolean ignoreConflicts)
throws IOException {
try {
workTreeUpdater = inCore ?
WorkTreeUpdater.createInCoreWorkTreeUpdater(db, dircache, getObjectInserter()) :
WorkTreeUpdater.createWorkTreeUpdater(db, dircache);
dircache = workTreeUpdater.getLockedDirCache();
tw = new NameConflictTreeWalk(db, reader);
tw.addTree(baseTree);
tw.setHead(tw.addTree(headTree));
tw.addTree(mergeTree);
DirCacheBuildIterator buildIt = workTreeUpdater.createDirCacheBuildIterator();
int dciPos = tw.addTree(buildIt);
if (workingTreeIterator != null) {
tw.addTree(workingTreeIterator);
workingTreeIterator.setDirCacheIterator(tw, dciPos);
} else {
tw.setFilter(TreeFilter.ANY_DIFF);
}
if (!mergeTreeWalk(tw, ignoreConflicts)) {
return false;
}
workTreeUpdater.writeWorkTreeChanges(true);
if (getUnmergedPaths().isEmpty() && !failed()) {
WorkTreeUpdater.Result result = workTreeUpdater.writeIndexChanges();
resultTree = result.getTreeId();
modifiedFiles = result.getModifiedFiles();
for (String f : result.getFailedToDelete()) {
failingPaths.put(f, MergeFailureReason.COULD_NOT_DELETE);
}
return result.getFailedToDelete().isEmpty();
}
resultTree = null;
return false;
} finally {
if(modifiedFiles.isEmpty()) {
modifiedFiles = workTreeUpdater.getModifiedFiles();
}
workTreeUpdater.close();
workTreeUpdater = null;
}
}
/**
* Process the given TreeWalk's entries.
*
* @param treeWalk
* The walk to iterate over.
* @param ignoreConflicts
* see
* {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
* @return Whether the trees merged cleanly.
* @throws java.io.IOException
* @since 3.5
*/
protected boolean mergeTreeWalk(TreeWalk treeWalk, boolean ignoreConflicts)
throws IOException {
boolean hasWorkingTreeIterator = tw.getTreeCount() > T_FILE;
boolean hasAttributeNodeProvider = treeWalk
.getAttributesNodeProvider() != null;
while (treeWalk.next()) {
Attributes[] attributes = {NO_ATTRIBUTES, NO_ATTRIBUTES,
NO_ATTRIBUTES};
if (hasAttributeNodeProvider) {
attributes[T_BASE] = treeWalk.getAttributes(T_BASE);
attributes[T_OURS] = treeWalk.getAttributes(T_OURS);
attributes[T_THEIRS] = treeWalk.getAttributes(T_THEIRS);
}
if (!processEntry(
treeWalk.getTree(T_BASE, CanonicalTreeParser.class),
treeWalk.getTree(T_OURS, CanonicalTreeParser.class),
treeWalk.getTree(T_THEIRS, CanonicalTreeParser.class),
treeWalk.getTree(T_INDEX, DirCacheBuildIterator.class),
hasWorkingTreeIterator ? treeWalk.getTree(T_FILE,
WorkingTreeIterator.class) : null,
ignoreConflicts, attributes)) {
workTreeUpdater.revertModifiedFiles();
return false;
}
if (treeWalk.isSubtree() && enterSubtree) {
treeWalk.enterSubtree();
}
}
return true;
}
}