Example usage for org.eclipse.jgit.notes NoteMapMerger NoteMapMerger

Introduction

In this page you can find the example usage for org.eclipse.jgit.notes NoteMapMerger NoteMapMerger.

Prototype

public NoteMapMerger(Repository db, NoteMerger noteMerger, MergeStrategy nonNotesMergeStrategy) 

Source Link

Document

Constructs a NoteMapMerger with custom org.eclipse.jgit.notes.NoteMerger and custom org.eclipse.jgit.merge.MergeStrategy .

Usage

From source file:com.google.appraise.eclipse.core.client.git.AppraiseGitReviewClient.java

License:Open Source License

/**
 * Merges the notes from local and origin commits with the given merge base.
 *//*  ww w .j a v a 2  s . c  o m*/
private void mergeNotesAndPush(RevWalk revWalk, String refName, RevCommit baseCommit, RevCommit localCommit,
        RevCommit originCommit) throws GitClientException {
    int remainingLockFailureCalls = JgitUtils.MAX_LOCK_FAILURE_CALLS;

    // Merge and commit.
    while (true) {
        try {
            NoteMap theirNoteMap = NoteMap.read(revWalk.getObjectReader(), originCommit);
            NoteMap ourNoteMap = NoteMap.read(revWalk.getObjectReader(), localCommit);
            NoteMap baseNoteMap;
            if (baseCommit != null) {
                baseNoteMap = NoteMap.read(revWalk.getObjectReader(), baseCommit);
            } else {
                baseNoteMap = NoteMap.newEmptyMap();
            }

            NoteMapMerger merger = new NoteMapMerger(repo, new DefaultNoteMerger(), MergeStrategy.RESOLVE);
            NoteMap merged = merger.merge(baseNoteMap, ourNoteMap, theirNoteMap);
            try (ObjectInserter inserter = repo.newObjectInserter()) {
                RevCommit mergeCommit = createNotesCommit(merged, inserter, revWalk, "Merged note commits\n",
                        localCommit, originCommit);

                RefUpdate update = JgitUtils.updateRef(repo, mergeCommit, localCommit, refName);
                Result result = update.update();
                if (result == Result.LOCK_FAILURE) {
                    if (--remainingLockFailureCalls > 0) {
                        Thread.sleep(JgitUtils.SLEEP_ON_LOCK_FAILURE_MS);
                    } else {
                        throw new GitClientException("Failed to lock the ref: " + refName);
                    }
                } else if (result == Result.REJECTED) {
                    throw new GitClientException("Rejected update to " + refName + ", this is unexpected");
                } else if (result == Result.IO_FAILURE) {
                    throw new GitClientException("I/O failure merging notes");
                } else {
                    // OK.
                    break;
                }
            }
        } catch (Exception e) {
            throw new GitClientException("Error merging notes commits", e);
        }
    }

    // And push.
    try {
        pushCommentsAndReviews();
    } catch (Exception e) {
        throw new GitClientException("Error pushing merge commit", e);
    }
}

---

From source file:com.google.gerrit.server.git.NotesBranchUtil.java

License:Apache License

private void updateRef(String notesBranch) throws IOException, MissingObjectException,
        IncorrectObjectTypeException, CorruptObjectException, ConcurrentRefUpdateException {
    if (baseCommit != null && oursCommit.getTree().equals(baseCommit.getTree())) {
        // If the trees are identical, there is no change in the notes.
        // Avoid saving this commit as it has no new information.
        return;/*from  w  w w . j  ava  2 s .  com*/
    }

    int remainingLockFailureCalls = MAX_LOCK_FAILURE_CALLS;
    RefUpdate refUpdate = createRefUpdate(notesBranch, oursCommit, baseCommit);

    for (;;) {
        Result result = refUpdate.update();

        if (result == Result.LOCK_FAILURE) {
            if (--remainingLockFailureCalls > 0) {
                try {
                    Thread.sleep(SLEEP_ON_LOCK_FAILURE_MS);
                } catch (InterruptedException e) {
                    // ignore
                }
            } else {
                throw new ConcurrentRefUpdateException("Failed to lock the ref: " + notesBranch,
                        refUpdate.getRef(), result);
            }

        } else if (result == Result.REJECTED) {
            RevCommit theirsCommit = revWalk.parseCommit(refUpdate.getOldObjectId());
            NoteMap theirs = NoteMap.read(revWalk.getObjectReader(), theirsCommit);
            NoteMapMerger merger = new NoteMapMerger(db, getNoteMerger(), MergeStrategy.RESOLVE);
            NoteMap merged = merger.merge(base, ours, theirs);
            RevCommit mergeCommit = createCommit(merged, gerritIdent, "Merged note commits\n", theirsCommit,
                    oursCommit);
            refUpdate = createRefUpdate(notesBranch, mergeCommit, theirsCommit);
            remainingLockFailureCalls = MAX_LOCK_FAILURE_CALLS;

        } else if (result == Result.IO_FAILURE) {
            throw new IOException("Couldn't update " + notesBranch + ". " + result.name());
        } else {
            gitRefUpdated.fire(project, refUpdate);
            break;
        }
    }
}

---