List of usage examples for org.eclipse.jgit.lib RefUpdate setExpectedOldObjectId
public void setExpectedOldObjectId(AnyObjectId id)
From source file:com.googlesource.gerrit.plugins.github.git.PullRequestCreateChange.java
License:Apache License
private Change.Id createNewChange(ReviewDb db, Repository git, RevWalk revWalk, Change.Key changeKey, Project.NameKey project, Ref destRef, Account.Id pullRequestOwner, RevCommit pullRequestCommit, RefControl refControl, String pullRequestMessage, String topic, boolean doValidation) throws OrmException, InvalidChangeOperationException, IOException { Change change = new Change(changeKey, new Change.Id(db.nextChangeId()), pullRequestOwner, new Branch.NameKey(project, destRef.getName()), TimeUtil.nowTs()); if (topic != null) { change.setTopic(topic);// w ww .j a v a2s. com } ChangeInserter ins = changeInserterFactory.create(refControl, change, pullRequestCommit); PatchSet newPatchSet = ins.getPatchSet(); if (doValidation) { validate(git, pullRequestCommit, refControl, newPatchSet); } final RefUpdate ru = git.updateRef(newPatchSet.getRefName()); ru.setExpectedOldObjectId(ObjectId.zeroId()); ru.setNewObjectId(pullRequestCommit); ru.disableRefLog(); if (ru.update(revWalk) != RefUpdate.Result.NEW) { throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(), change.getDest().getParentKey().get(), ru.getResult())); } ins.setMessage(buildChangeMessage(db, change, newPatchSet, pullRequestOwner, pullRequestMessage)).insert(); return change.getId(); }
From source file:com.mangosolutions.rcloud.rawgist.repository.git.BareCommitCommand.java
/** * Executes the {@code commit} command with all the options and parameters * collected by the setter methods of this class. Each instance of this * class should only be used for one invocation of the command (means: one * call to {@link #call()})/*from ww w.j a va 2s . c o m*/ * * @return a {@link RevCommit} object representing the successful commit. * @throws NoHeadException * when called on a git repo without a HEAD reference * @throws NoMessageException * when called without specifying a commit message * @throws UnmergedPathsException * when the current index contained unmerged paths (conflicts) * @throws ConcurrentRefUpdateException * when HEAD or branch ref is updated concurrently by someone * else * @throws WrongRepositoryStateException * when repository is not in the right state for committing * @throws AbortedByHookException * if there are either pre-commit or commit-msg hooks present in * the repository and one of them rejects the commit. */ public RevCommit call() throws GitAPIException, NoHeadException, NoMessageException, UnmergedPathsException, ConcurrentRefUpdateException, WrongRepositoryStateException, AbortedByHookException { checkCallable(); Collections.sort(only); try (RevWalk rw = new RevWalk(repo)) { RepositoryState state = repo.getRepositoryState(); if (!noVerify) { Hooks.preCommit(repo, hookOutRedirect).call(); } processOptions(state, rw); if (all && !repo.isBare()) { try (Git git = new Git(repo)) { git.add().addFilepattern(".") //$NON-NLS-1$ .setUpdate(true).call(); } catch (NoFilepatternException e) { // should really not happen throw new JGitInternalException(e.getMessage(), e); } } Ref head = repo.findRef(Constants.HEAD); if (head == null) { throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported); } // determine the current HEAD and the commit it is referring to ObjectId headId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$ if (headId == null && amend) throw new WrongRepositoryStateException(JGitText.get().commitAmendOnInitialNotPossible); if (headId != null) { if (amend) { RevCommit previousCommit = rw.parseCommit(headId); for (RevCommit p : previousCommit.getParents()) parents.add(p.getId()); if (author == null) author = previousCommit.getAuthorIdent(); } else { parents.add(0, headId); } } if (!noVerify) { message = Hooks.commitMsg(repo, hookOutRedirect).setCommitMessage(message).call(); } // lock the index // DirCache index = repo.lockDirCache(); index.lock(); try (ObjectInserter odi = repo.newObjectInserter()) { if (!only.isEmpty()) index = createTemporaryIndex(headId, index, rw); // Write the index as tree to the object database. This may // fail for example when the index contains unmerged paths // (unresolved conflicts) ObjectId indexTreeId = index.writeTree(odi); if (insertChangeId) insertChangeId(indexTreeId); // Check for empty commits if (headId != null && !allowEmpty.booleanValue()) { RevCommit headCommit = rw.parseCommit(headId); headCommit.getTree(); if (indexTreeId.equals(headCommit.getTree())) { return null; } } // Create a Commit object, populate it and write it CommitBuilder commit = new CommitBuilder(); commit.setCommitter(committer); commit.setAuthor(author); commit.setMessage(message); commit.setParentIds(parents); commit.setTreeId(indexTreeId); ObjectId commitId = odi.insert(commit); odi.flush(); RevCommit revCommit = rw.parseCommit(commitId); RefUpdate ru = repo.updateRef(Constants.HEAD); ru.setNewObjectId(commitId); if (reflogComment != null) { ru.setRefLogMessage(reflogComment, false); } else { String prefix = amend ? "commit (amend): " //$NON-NLS-1$ : parents.size() == 0 ? "commit (initial): " //$NON-NLS-1$ : "commit: "; //$NON-NLS-1$ ru.setRefLogMessage(prefix + revCommit.getShortMessage(), false); } if (headId != null) { ru.setExpectedOldObjectId(headId); } else { ru.setExpectedOldObjectId(ObjectId.zeroId()); } Result rc = ru.forceUpdate(); switch (rc) { case NEW: case FORCED: case FAST_FORWARD: { setCallable(false); if (state == RepositoryState.MERGING_RESOLVED || isMergeDuringRebase(state)) { // Commit was successful. Now delete the files // used for merge commits repo.writeMergeCommitMsg(null); repo.writeMergeHeads(null); } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) { repo.writeMergeCommitMsg(null); repo.writeCherryPickHead(null); } else if (state == RepositoryState.REVERTING_RESOLVED) { repo.writeMergeCommitMsg(null); repo.writeRevertHead(null); } return revCommit; } case REJECTED: case LOCK_FAILURE: throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, ru.getRef(), rc); default: throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed, Constants.HEAD, commitId.toString(), rc)); } } finally { index.unlock(); } } catch (UnmergedPathException e) { throw new UnmergedPathsException(e); } catch (IOException e) { throw new JGitInternalException(JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e); } }
From source file:com.microsoft.gittf.core.util.StashUtil.java
License:Open Source License
/** * Creates a stash// ww w . ja va 2 s .c o m * * @param repository * the git repository * @param repositoryInserter * the repository inserter object to use * @param rootBaseTree * the tree id for the base commit of the stash * @param rootStashTree * the tree id for the commit of the stash * @param rootIndexTree * the tree id for the index commit of the stash * @param baseParentId * the parent of the base tree commit * @param ownerDisplayName * the owner display name of the stash * @param ownerName * the owner name of the stash * @param stashComment * the comment used to for the stash * @param stashName * the stash name * @return * @throws IOException */ public static final ObjectId create(final Repository repository, final ObjectInserter repositoryInserter, final ObjectId rootBaseTree, final ObjectId rootStashTree, final ObjectId rootIndexTree, final ObjectId baseParentId, final String ownerDisplayName, final String ownerName, final String stashComment, final String stashName) throws IOException { Check.notNull(repository, "repository"); //$NON-NLS-1$ Check.notNull(repositoryInserter, "repositoryInserter"); //$NON-NLS-1$ Check.notNull(rootBaseTree, "rootBaseTree"); //$NON-NLS-1$ Check.notNull(rootStashTree, "rootStashTree"); //$NON-NLS-1$ Check.notNull(rootIndexTree, "rootIndexTree"); //$NON-NLS-1$ /* identifies the head and the branch we are creating the stash for */ Ref headReference = repository.getRef(Constants.HEAD); RevCommit headCommit = new RevWalk(repository).parseCommit(headReference.getObjectId()); String currentBranchName = Repository.shortenRefName(headReference.getTarget().getName()); PersonIdent author = new PersonIdent(ownerDisplayName, ownerName); /* create the base commit */ CommitBuilder commitBuilder = new CommitBuilder(); commitBuilder.setTreeId(rootBaseTree); if (baseParentId != null) { commitBuilder.setParentId(baseParentId); } commitBuilder.setMessage(stashComment); commitBuilder.setAuthor(author); commitBuilder.setCommitter(author); ObjectId baseCommit = repositoryInserter.insert(commitBuilder); /* create the index commit */ commitBuilder.setTreeId(rootIndexTree); commitBuilder.setParentId(baseCommit); commitBuilder.setMessage(MessageFormat.format(STASH_INDEX_COMMENT, currentBranchName, headCommit.abbreviate(7).name(), stashName)); commitBuilder.setAuthor(author); commitBuilder.setCommitter(author); ObjectId indexCommit = repositoryInserter.insert(commitBuilder); /* create the stash commit */ commitBuilder.setTreeId(rootStashTree); commitBuilder.setParentId(baseCommit); commitBuilder.addParentId(indexCommit); String stashRefLogComment = MessageFormat.format(STASH_COMMENT, currentBranchName, headCommit.abbreviate(7).name(), stashName); commitBuilder.setMessage(stashRefLogComment); ObjectId stashCommit = repositoryInserter.insert(commitBuilder); repositoryInserter.flush(); /* Update the stash reference and ref log */ RefUpdate stashReferenceUpdate = repository.updateRef(Constants.R_STASH); stashReferenceUpdate.setNewObjectId(stashCommit); stashReferenceUpdate.setRefLogIdent(author); stashReferenceUpdate.setRefLogMessage(stashRefLogComment, false); Ref currentStashRef = repository.getRef(Constants.R_STASH); if (currentStashRef != null) { stashReferenceUpdate.setExpectedOldObjectId(currentStashRef.getObjectId()); } else { stashReferenceUpdate.setExpectedOldObjectId(ObjectId.zeroId()); } stashReferenceUpdate.forceUpdate(); return stashCommit; }
From source file:jbyoshi.gitupdate.processor.FastForward.java
License:Apache License
private static boolean tryFastForward(Repository repo, Ref ref, Ref target, Report report) throws GitAPIException, IOException { if (ref == null || target == null) { return false; }//from www .j ava 2 s . c o m target = repo.peel(target); if (!ref.equals(repo.getRef(Constants.HEAD).getTarget())) { try (RevWalk revWalk = new RevWalk(repo)) { ObjectId targetId = target.getPeeledObjectId(); if (targetId == null) { targetId = target.getObjectId(); } RevCommit targetCommit = revWalk.lookupCommit(targetId); ObjectId sourceId = ref.getObjectId(); RevCommit sourceCommit = revWalk.lookupCommit(sourceId); if (revWalk.isMergedInto(sourceCommit, targetCommit)) { RefUpdate refUpdate = repo.updateRef(ref.getName()); refUpdate.setNewObjectId(targetCommit); refUpdate.setRefLogMessage("Fast forward", false); refUpdate.setExpectedOldObjectId(sourceId); Result rc = refUpdate.update(); switch (rc) { case NEW: case FAST_FORWARD: report.newChild(ref.getName() + " -> " + target.getName()).modified(); return true; case REJECTED: case LOCK_FAILURE: report.newErrorChild(new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, refUpdate.getRef(), rc)); break; case NO_CHANGE: break; default: report.newErrorChild(new JGitInternalException(MessageFormat .format(JGitText.get().updatingRefFailed, ref.getName(), targetId.toString(), rc))); break; } } return false; } } try { MergeResult result = Git.wrap(repo).merge().setFastForward(MergeCommand.FastForwardMode.FF_ONLY) .include(target.getTarget()).call(); if (result.getMergeStatus() == MergeResult.MergeStatus.ALREADY_UP_TO_DATE) { // Ignore } else if (result.getMergeStatus() == MergeResult.MergeStatus.FAST_FORWARD) { report.newChild("Fast-forwarded " + ref.getName() + " to " + target.getName()).modified(); return true; } else { report.newChild("Fast-forward failed: status " + result.getMergeStatus()).error(); } } catch (NoHeadException e) { // Ignore } return false; }
From source file:org.kie.commons.java.nio.fs.jgit.util.JGitUtil.java
License:Apache License
public static void commit(final Git git, final String branchName, final String name, final String email, final String message, final TimeZone timeZone, final Date when, final Map<String, File> content) { final PersonIdent author = buildPersonIdent(git, name, email, timeZone, when); try {// ww w. j ava 2s . com final ObjectInserter odi = git.getRepository().newObjectInserter(); try { // Create the in-memory index of the new/updated issue. final ObjectId headId = git.getRepository().resolve(branchName + "^{commit}"); final DirCache index = createTemporaryIndex(git, headId, content); final ObjectId indexTreeId = index.writeTree(odi); // Create a commit object final CommitBuilder commit = new CommitBuilder(); commit.setAuthor(author); commit.setCommitter(author); commit.setEncoding(Constants.CHARACTER_ENCODING); commit.setMessage(message); //headId can be null if the repository has no commit yet if (headId != null) { commit.setParentId(headId); } commit.setTreeId(indexTreeId); // Insert the commit into the repository final ObjectId commitId = odi.insert(commit); odi.flush(); final RevWalk revWalk = new RevWalk(git.getRepository()); try { final RevCommit revCommit = revWalk.parseCommit(commitId); final RefUpdate ru = git.getRepository().updateRef("refs/heads/" + branchName); if (headId == null) { ru.setExpectedOldObjectId(ObjectId.zeroId()); } else { ru.setExpectedOldObjectId(headId); } ru.setNewObjectId(commitId); ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false); final RefUpdate.Result rc = ru.forceUpdate(); switch (rc) { case NEW: case FORCED: case FAST_FORWARD: break; case REJECTED: case LOCK_FAILURE: throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, ru.getRef(), rc); default: throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed, Constants.HEAD, commitId.toString(), rc)); } } finally { revWalk.release(); } } finally { odi.release(); } } catch (final Throwable t) { throw new RuntimeException(t); } }
From source file:org.kie.commons.java.nio.fs.jgit.util.JGitUtil.java
License:Apache License
public static MergeResult mergeBranches(final Git git, final String source, final String target) throws Exception { final Repository repo = git.getRepository(); final MergeStrategy mergeStrategy = MergeStrategy.RESOLVE; final List<Ref> commits = new LinkedList<Ref>(); final boolean squash = false; RevWalk revWalk = null;//www. java 2 s. c o m DirCacheCheckout dco = null; try { Ref head = repo.getRef(Constants.HEAD); if (head == null) { throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported); } final StringBuilder refLogMessage = new StringBuilder("merge "); // Check for FAST_FORWARD, ALREADY_UP_TO_DATE revWalk = new RevWalk(repo); // we know for now there is only one commit Ref ref = commits.get(0); refLogMessage.append(ref.getName()); // handle annotated tags ObjectId objectId = ref.getPeeledObjectId(); if (objectId == null) { objectId = ref.getObjectId(); } final RevCommit srcCommit = revWalk.lookupCommit(objectId); ObjectId headId = head.getObjectId(); if (headId == null) { revWalk.parseHeaders(srcCommit); dco = new DirCacheCheckout(repo, repo.lockDirCache(), srcCommit.getTree()); dco.setFailOnConflict(true); dco.checkout(); RefUpdate refUpdate = repo.updateRef(head.getTarget().getName()); refUpdate.setNewObjectId(objectId); refUpdate.setExpectedOldObjectId(null); refUpdate.setRefLogMessage("initial pull", false); if (refUpdate.update() != RefUpdate.Result.NEW) { throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported); } return new MergeResult(srcCommit, srcCommit, new ObjectId[] { null, srcCommit }, MergeStatus.FAST_FORWARD, mergeStrategy, null, null); } final RevCommit headCommit = revWalk.lookupCommit(headId); if (revWalk.isMergedInto(srcCommit, headCommit)) { return new MergeResult(headCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, ALREADY_UP_TO_DATE, mergeStrategy, null, null); } else if (revWalk.isMergedInto(headCommit, srcCommit)) { // FAST_FORWARD detected: skip doing a real merge but only // update HEAD refLogMessage.append(": " + FAST_FORWARD); dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(), srcCommit.getTree()); dco.setFailOnConflict(true); dco.checkout(); String msg = null; ObjectId newHead, base = null; final MergeStatus mergeStatus; if (!squash) { updateHead(git, refLogMessage, srcCommit, headId); newHead = base = srcCommit; mergeStatus = FAST_FORWARD; } else { msg = JGitText.get().squashCommitNotUpdatingHEAD; newHead = base = headId; mergeStatus = FAST_FORWARD_SQUASHED; final List<RevCommit> squashedCommits = RevWalkUtils.find(revWalk, srcCommit, headCommit); final String squashMessage = new SquashMessageFormatter().format(squashedCommits, head); repo.writeSquashCommitMsg(squashMessage); } return new MergeResult(newHead, base, new ObjectId[] { headCommit, srcCommit }, mergeStatus, mergeStrategy, null, msg); } else { String mergeMessage = ""; if (!squash) { mergeMessage = new MergeMessageFormatter().format(commits, head); repo.writeMergeCommitMsg(mergeMessage); repo.writeMergeHeads(Arrays.asList(ref.getObjectId())); } else { final List<RevCommit> squashedCommits = RevWalkUtils.find(revWalk, srcCommit, headCommit); final String squashMessage = new SquashMessageFormatter().format(squashedCommits, head); repo.writeSquashCommitMsg(squashMessage); } boolean noProblems; final Merger merger = mergeStrategy.newMerger(repo); final Map<String, org.eclipse.jgit.merge.MergeResult<?>> lowLevelResults; final Map<String, ResolveMerger.MergeFailureReason> failingPaths; final List<String> unmergedPaths; if (merger instanceof ResolveMerger) { ResolveMerger resolveMerger = (ResolveMerger) merger; resolveMerger.setCommitNames(new String[] { "BASE", "HEAD", ref.getName() }); resolveMerger.setWorkingTreeIterator(new FileTreeIterator(repo)); noProblems = merger.merge(headCommit, srcCommit); lowLevelResults = resolveMerger.getMergeResults(); failingPaths = resolveMerger.getFailingPaths(); unmergedPaths = resolveMerger.getUnmergedPaths(); } else { noProblems = merger.merge(headCommit, srcCommit); lowLevelResults = emptyMap(); failingPaths = emptyMap(); unmergedPaths = emptyList(); } refLogMessage.append(": Merge made by "); refLogMessage.append(mergeStrategy.getName()); refLogMessage.append('.'); if (noProblems) { dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(), merger.getResultTreeId()); dco.setFailOnConflict(true); dco.checkout(); String msg = null; RevCommit newHead = null; MergeStatus mergeStatus = null; if (!squash) { newHead = new Git(repo).commit().setReflogComment(refLogMessage.toString()).call(); mergeStatus = MERGED; } else { msg = JGitText.get().squashCommitNotUpdatingHEAD; newHead = headCommit; mergeStatus = MERGED_SQUASHED; } return new MergeResult(newHead.getId(), null, new ObjectId[] { headCommit.getId(), srcCommit.getId() }, mergeStatus, mergeStrategy, null, msg); } else { if (failingPaths != null && !failingPaths.isEmpty()) { repo.writeMergeCommitMsg(null); repo.writeMergeHeads(null); return new MergeResult(null, merger.getBaseCommit(0, 1), new ObjectId[] { headCommit.getId(), srcCommit.getId() }, FAILED, mergeStrategy, lowLevelResults, failingPaths, null); } else { final String mergeMessageWithConflicts = new MergeMessageFormatter() .formatWithConflicts(mergeMessage, unmergedPaths); repo.writeMergeCommitMsg(mergeMessageWithConflicts); return new MergeResult(null, merger.getBaseCommit(0, 1), new ObjectId[] { headCommit.getId(), srcCommit.getId() }, CONFLICTING, mergeStrategy, lowLevelResults, null); } } } } catch (org.eclipse.jgit.errors.CheckoutConflictException e) { final List<String> conflicts = (dco == null) ? Collections.<String>emptyList() : dco.getConflicts(); throw new CheckoutConflictException(conflicts, e); } catch (java.io.IOException e) { throw new JGitInternalException( MessageFormat.format(JGitText.get().exceptionCaughtDuringExecutionOfMergeCommand, e), e); } finally { if (revWalk != null) { revWalk.release(); } } }
From source file:org.kie.commons.java.nio.fs.jgit.util.JGitUtil.java
License:Apache License
private static void updateHead(final Git git, final StringBuilder refLogMessage, final ObjectId newHeadId, final ObjectId oldHeadID) throws java.io.IOException, ConcurrentRefUpdateException { RefUpdate refUpdate = git.getRepository().updateRef(Constants.HEAD); refUpdate.setNewObjectId(newHeadId); refUpdate.setRefLogMessage(refLogMessage.toString(), false); refUpdate.setExpectedOldObjectId(oldHeadID); RefUpdate.Result rc = refUpdate.update(); switch (rc) { case NEW://from ww w . ja v a2 s . c o m case FAST_FORWARD: return; case REJECTED: case LOCK_FAILURE: throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, refUpdate.getRef(), rc); default: throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed, Constants.HEAD, newHeadId.toString(), rc)); } }
From source file:org.moxie.utils.JGitUtils.java
License:Apache License
public static void updateGhPages(File repositoryFolder, File sourceFolder, boolean obliterate) { String ghpages = "refs/heads/gh-pages"; try {//from ww w . ja v a 2 s . co m File gitDir = FileKey.resolve(repositoryFolder, FS.DETECTED); Repository repository = new FileRepository(gitDir); ObjectId objectId = repository.resolve(ghpages); if (objectId == null) { JGitUtils.createOrphanBranch(repository, "gh-pages", null); } System.out.println("Updating gh-pages branch..."); ObjectId headId = repository.resolve(ghpages + "^{commit}"); ObjectInserter odi = repository.newObjectInserter(); try { // Create the in-memory index of the new/updated issue. DirCache index = createIndex(repository, headId, sourceFolder, obliterate); ObjectId indexTreeId = index.writeTree(odi); // Create a commit object PersonIdent author = new PersonIdent("Moxie", "moxie@localhost"); CommitBuilder commit = new CommitBuilder(); commit.setAuthor(author); commit.setCommitter(author); commit.setEncoding(Constants.CHARACTER_ENCODING); commit.setMessage("updated pages"); commit.setParentId(headId); commit.setTreeId(indexTreeId); // Insert the commit into the repository ObjectId commitId = odi.insert(commit); odi.flush(); RevWalk revWalk = new RevWalk(repository); try { RevCommit revCommit = revWalk.parseCommit(commitId); RefUpdate ru = repository.updateRef(ghpages); ru.setNewObjectId(commitId); ru.setExpectedOldObjectId(headId); ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false); Result rc = ru.forceUpdate(); switch (rc) { case NEW: case FORCED: case FAST_FORWARD: break; case REJECTED: case LOCK_FAILURE: throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, ru.getRef(), rc); default: throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed, ghpages, commitId.toString(), rc)); } } finally { revWalk.release(); } } finally { odi.release(); } System.out.println("gh-pages updated."); } catch (Throwable t) { t.printStackTrace(); } }
From source file:org.test.RewriteGitHistory.java
License:Apache License
/** * Apply the commit on the current branch and update the head pointer. * // w w w . j a va 2s . c om * @param commitBuilder * @throws IOException * @throws NoHeadException */ protected ObjectId executeCommit(CommitBuilder commitBuilder) throws NoHeadException, IOException { ObjectInserter inserter = repository.getObjectDatabase().newInserter(); ObjectId newBaseId = null; try { newBaseId = inserter.insert(commitBuilder); inserter.flush(); Ref head = repository.getRef(Constants.HEAD); if (head == null) throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported); // determine the current HEAD and the commit it is referring to ObjectId headId = repository.resolve(Constants.HEAD + "^{commit}"); RevWalk revWalk = new RevWalk(repository); try { RevCommit newCommit = revWalk.parseCommit(newBaseId); RefUpdate ru = repository.updateRef(Constants.HEAD); ru.setNewObjectId(newBaseId); ru.setRefLogMessage("commit : " + newCommit.getShortMessage(), false); ru.setExpectedOldObjectId(headId); Result rc = ru.update(); log.info("rc.type = " + rc.name()); } finally { revWalk.release(); } } finally { inserter.release(); } return newBaseId; }
From source file:org.uberfire.java.nio.fs.jgit.util.commands.RefTreeUpdateCommand.java
License:Apache License
private void commit(final Repository repo, final RevCommit original, final BiFunction fun) throws IOException { try (final ObjectReader reader = repo.newObjectReader(); final ObjectInserter inserter = repo.newObjectInserter(); final RevWalk rw = new RevWalk(reader)) { final RefTreeDatabase refdb = (RefTreeDatabase) repo.getRefDatabase(); final RefDatabase bootstrap = refdb.getBootstrap(); final RefUpdate refUpdate = bootstrap.newUpdate(refdb.getTxnCommitted(), false); final CommitBuilder cb = new CommitBuilder(); final Ref ref = bootstrap.exactRef(refdb.getTxnCommitted()); final RefTree tree; if (ref != null && ref.getObjectId() != null) { tree = RefTree.read(reader, rw.parseTree(ref.getObjectId())); cb.setParentId(ref.getObjectId()); refUpdate.setExpectedOldObjectId(ref.getObjectId()); } else {// w w w . j av a 2s .c om tree = RefTree.newEmptyTree(); refUpdate.setExpectedOldObjectId(ObjectId.zeroId()); } if (fun.apply(reader, tree)) { final Ref ref2 = bootstrap.exactRef(refdb.getTxnCommitted()); if (ref2 == null || ref2.getObjectId().equals(ref != null ? ref.getObjectId() : null)) { cb.setTreeId(tree.writeTree(inserter)); if (original != null) { cb.setAuthor(original.getAuthorIdent()); cb.setCommitter(original.getAuthorIdent()); } else { final PersonIdent personIdent = new PersonIdent("user", "user@example.com"); cb.setAuthor(personIdent); cb.setCommitter(personIdent); } refUpdate.setNewObjectId(inserter.insert(cb)); inserter.flush(); final RefUpdate.Result result = refUpdate.update(rw); switch (result) { case NEW: case FAST_FORWARD: break; default: throw new RuntimeException( repo.getDirectory() + " -> " + result.toString() + " : " + refUpdate.getName()); } final File commited = new File(repo.getDirectory(), refdb.getTxnCommitted()); final File accepted = new File(repo.getDirectory(), refdb.getTxnNamespace() + "accepted"); Files.copy(commited.toPath(), accepted.toPath(), StandardCopyOption.REPLACE_EXISTING); } } } }