/// <summary>checks if we can fast-forward and returns the new head if it is possible /// </summary> /// <param name="newCommit"></param> /// <returns>the new head, or null</returns> /// <exception cref="NGit.Api.Errors.RefNotFoundException">NGit.Api.Errors.RefNotFoundException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual RevCommit TryFastForward(RevCommit newCommit) { Ref head = repo.GetRef(Constants.HEAD); if (head == null || head.GetObjectId() == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } ObjectId headId = head.GetObjectId(); if (headId == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } RevCommit headCommit = walk.LookupCommit(headId); if (walk.IsMergedInto(newCommit, headCommit)) { return(newCommit); } string headName; if (head.IsSymbolic()) { headName = head.GetTarget().GetName(); } else { headName = "detached HEAD"; } return(TryFastForward(headName, headCommit, newCommit)); }
/// <exception cref="System.IO.IOException"></exception> private RefUpdate.Result UpdateImpl(RevWalk walk, RefUpdate.Store store) { RevObject newObj; RevObject oldObj; if (GetRefDatabase().IsNameConflicting(GetName())) { return(RefUpdate.Result.LOCK_FAILURE); } try { if (!TryLock(true)) { return(RefUpdate.Result.LOCK_FAILURE); } if (expValue != null) { ObjectId o; o = oldValue != null ? oldValue : ObjectId.ZeroId; if (!AnyObjectId.Equals(expValue, o)) { return(RefUpdate.Result.LOCK_FAILURE); } } if (oldValue == null) { return(store.Execute(RefUpdate.Result.NEW)); } newObj = SafeParse(walk, newValue); oldObj = SafeParse(walk, oldValue); if (newObj == oldObj && !detachingSymbolicRef) { return(store.Execute(RefUpdate.Result.NO_CHANGE)); } if (newObj is RevCommit && oldObj is RevCommit) { if (walk.IsMergedInto((RevCommit)oldObj, (RevCommit)newObj)) { return(store.Execute(RefUpdate.Result.FAST_FORWARD)); } } if (IsForceUpdate()) { return(store.Execute(RefUpdate.Result.FORCED)); } return(RefUpdate.Result.REJECTED); } finally { Unlock(); } }
/// <summary>Update the type of this command by checking for fast-forward.</summary> /// <remarks> /// Update the type of this command by checking for fast-forward. /// <p> /// If the command's current type is UPDATE, a merge test will be performed /// using the supplied RevWalk to determine if /// <see cref="GetOldId()">GetOldId()</see> /// is fully /// merged into /// <see cref="GetNewId()">GetNewId()</see> /// . If some commits are not merged the /// update type is changed to /// <see cref="Type.UPDATE_NONFASTFORWARD">Type.UPDATE_NONFASTFORWARD</see> /// . /// </remarks> /// <param name="walk"> /// an instance to perform the merge test with. The caller must /// allocate and release this object. /// </param> /// <exception cref="System.IO.IOException"> /// either oldId or newId is not accessible in the repository /// used by the RevWalk. This usually indicates data corruption, /// and the command cannot be processed. /// </exception> public virtual void UpdateType(RevWalk walk) { if (typeIsCorrect) { return; } if (type == ReceiveCommand.Type.UPDATE && !AnyObjectId.Equals(oldId, newId)) { RevObject o = walk.ParseAny(oldId); RevObject n = walk.ParseAny(newId); if (!(o is RevCommit) || !(n is RevCommit) || !walk.IsMergedInto((RevCommit)o, (RevCommit )n)) { SetType(ReceiveCommand.Type.UPDATE_NONFASTFORWARD); } } typeIsCorrect = true; }
public bool IsBranchMerged (string branchName) { // check if a branch is merged into HEAD RevWalk walk = new RevWalk(RootRepository); RevCommit tip = walk.ParseCommit(RootRepository.Resolve(Constants.HEAD)); Ref currentRef = RootRepository.GetRef(branchName); if (currentRef == null) return true; RevCommit @base = walk.ParseCommit(RootRepository.Resolve(branchName)); return walk.IsMergedInto(@base, tip); }
/// <exception cref="NGit.Api.Errors.NotMergedException"> /// when trying to delete a branch which has not been merged into /// the currently checked out branch without force /// </exception> /// <exception cref="NGit.Api.Errors.CannotDeleteCurrentBranchException">NGit.Api.Errors.CannotDeleteCurrentBranchException /// </exception> /// <returns>the list with the (full) names of the deleted branches</returns> /// <exception cref="NGit.Api.Errors.GitAPIException"></exception> public override IList <string> Call() { CheckCallable(); IList <string> result = new AList <string>(); if (branchNames.IsEmpty()) { return(result); } try { string currentBranch = repo.GetFullBranch(); if (!force) { // check if the branches to be deleted // are all merged into the current branch RevWalk walk = new RevWalk(repo); RevCommit tip = walk.ParseCommit(repo.Resolve(Constants.HEAD)); foreach (string branchName in branchNames) { if (branchName == null) { continue; } Ref currentRef = repo.GetRef(branchName); if (currentRef == null) { continue; } RevCommit @base = walk.ParseCommit(repo.Resolve(branchName)); if (!walk.IsMergedInto(@base, tip)) { throw new NotMergedException(); } } } SetCallable(false); foreach (string branchName_1 in branchNames) { if (branchName_1 == null) { continue; } Ref currentRef = repo.GetRef(branchName_1); if (currentRef == null) { continue; } string fullName = currentRef.GetName(); if (fullName.Equals(currentBranch)) { throw new CannotDeleteCurrentBranchException(MessageFormat.Format(JGitText.Get(). cannotDeleteCheckedOutBranch, branchName_1)); } RefUpdate update = repo.UpdateRef(fullName); update.SetRefLogMessage("branch deleted", false); update.SetForceUpdate(true); RefUpdate.Result deleteResult = update.Delete(); bool ok = true; switch (deleteResult) { case RefUpdate.Result.IO_FAILURE: case RefUpdate.Result.LOCK_FAILURE: case RefUpdate.Result.REJECTED: { ok = false; break; } default: { break; break; } } if (ok) { result.AddItem(fullName); if (fullName.StartsWith(Constants.R_HEADS)) { string shortenedName = Sharpen.Runtime.Substring(fullName, Constants.R_HEADS.Length ); // remove upstream configuration if any StoredConfig cfg = repo.GetConfig(); cfg.UnsetSection(ConfigConstants.CONFIG_BRANCH_SECTION, shortenedName); cfg.Save(); } } else { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().deleteBranchUnexpectedResult , deleteResult.ToString())); } } return(result); } catch (IOException ioe) { throw new JGitInternalException(ioe.Message, ioe); } }
/// <exception cref="System.IO.IOException"></exception> private RefUpdate.Result UpdateImpl(RevWalk walk, RefUpdate.Store store) { RevObject newObj; RevObject oldObj; if (GetRefDatabase().IsNameConflicting(GetName())) { return RefUpdate.Result.LOCK_FAILURE; } try { if (!TryLock(true)) { return RefUpdate.Result.LOCK_FAILURE; } if (expValue != null) { ObjectId o; o = oldValue != null ? oldValue : ObjectId.ZeroId; if (!AnyObjectId.Equals(expValue, o)) { return RefUpdate.Result.LOCK_FAILURE; } } if (oldValue == null) { return store.Execute(RefUpdate.Result.NEW); } newObj = SafeParse(walk, newValue); oldObj = SafeParse(walk, oldValue); if (newObj == oldObj && !detachingSymbolicRef) { return store.Execute(RefUpdate.Result.NO_CHANGE); } if (newObj is RevCommit && oldObj is RevCommit) { if (walk.IsMergedInto((RevCommit)oldObj, (RevCommit)newObj)) { return store.Execute(RefUpdate.Result.FAST_FORWARD); } } if (IsForceUpdate()) { return store.Execute(RefUpdate.Result.FORCED); } return RefUpdate.Result.REJECTED; } finally { Unlock(); } }
/// <summary> /// Executes the /// <code>Merge</code> /// command with all the options and parameters /// collected by the setter methods (e.g. /// <see cref="Include(NGit.Ref)">Include(NGit.Ref)</see> /// ) of this /// class. Each instance of this class should only be used for one invocation /// of the command. Don't call this method twice on an instance. /// </summary> /// <returns>the result of the merge</returns> /// <exception cref="NGit.Api.Errors.NoHeadException"></exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"></exception> /// <exception cref="NGit.Api.Errors.CheckoutConflictException"></exception> /// <exception cref="NGit.Api.Errors.InvalidMergeHeadsException"></exception> /// <exception cref="NGit.Api.Errors.WrongRepositoryStateException"></exception> /// <exception cref="NGit.Api.Errors.NoMessageException"></exception> public override MergeCommandResult Call() { CheckCallable(); if (commits.Count != 1) { throw new InvalidMergeHeadsException(commits.IsEmpty() ? JGitText.Get().noMergeHeadSpecified : MessageFormat.Format(JGitText.Get().mergeStrategyDoesNotSupportHeads, mergeStrategy .GetName(), Sharpen.Extensions.ValueOf(commits.Count))); } RevWalk revWalk = null; try { Ref head = repo.GetRef(Constants.HEAD); if (head == null) { throw new NoHeadException(JGitText.Get().commitOnRepoWithoutHEADCurrentlyNotSupported ); } 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[0]; refLogMessage.Append(@ref.GetName()); // handle annotated tags ObjectId objectId = @ref.GetPeeledObjectId(); if (objectId == null) { objectId = @ref.GetObjectId(); } RevCommit srcCommit = revWalk.LookupCommit(objectId); ObjectId headId = head.GetObjectId(); if (headId == null) { revWalk.ParseHeaders(srcCommit); DirCacheCheckout dco = new DirCacheCheckout(repo, repo.LockDirCache(), srcCommit. Tree); 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 ); } SetCallable(false); return(new MergeCommandResult(srcCommit, srcCommit, new ObjectId[] { null, srcCommit }, MergeStatus.FAST_FORWARD, mergeStrategy, null, null)); } RevCommit headCommit = revWalk.LookupCommit(headId); if (revWalk.IsMergedInto(srcCommit, headCommit)) { SetCallable(false); return(new MergeCommandResult(headCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, MergeStatus.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(": " + MergeStatus.FAST_FORWARD); DirCacheCheckout dco = new DirCacheCheckout(repo, headCommit.Tree, repo.LockDirCache (), srcCommit.Tree); dco.SetFailOnConflict(true); dco.Checkout(); UpdateHead(refLogMessage, srcCommit, headId); SetCallable(false); return(new MergeCommandResult(srcCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, MergeStatus.FAST_FORWARD, mergeStrategy, null, null)); } else { repo.WriteMergeCommitMsg(new MergeMessageFormatter().Format(commits, head)); repo.WriteMergeHeads(Arrays.AsList(@ref.GetObjectId())); ThreeWayMerger merger = (ThreeWayMerger)mergeStrategy.NewMerger(repo); bool noProblems; IDictionary <string, MergeResult <NGit.Diff.Sequence> > lowLevelResults = null; IDictionary <string, ResolveMerger.MergeFailureReason> failingPaths = null; if (merger is 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(); } else { noProblems = merger.Merge(headCommit, srcCommit); } if (noProblems) { DirCacheCheckout dco = new DirCacheCheckout(repo, headCommit.Tree, repo.LockDirCache (), merger.GetResultTreeId()); dco.SetFailOnConflict(true); dco.Checkout(); RevCommit newHead = new Git(GetRepository()).Commit().Call(); return(new MergeCommandResult(newHead.Id, null, new ObjectId[] { headCommit.Id, srcCommit .Id }, MergeStatus.MERGED, mergeStrategy, null, null)); } else { if (failingPaths != null) { repo.WriteMergeCommitMsg(null); repo.WriteMergeHeads(null); return(new MergeCommandResult(null, merger.GetBaseCommit(0, 1), new ObjectId[] { headCommit.Id, srcCommit.Id }, MergeStatus.FAILED, mergeStrategy, lowLevelResults , null)); } else { return(new MergeCommandResult(null, merger.GetBaseCommit(0, 1), new ObjectId[] { headCommit.Id, srcCommit.Id }, MergeStatus.CONFLICTING, mergeStrategy, lowLevelResults , null)); } } } } } catch (IOException e) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().exceptionCaughtDuringExecutionOfMergeCommand , e), e); } finally { if (revWalk != null) { revWalk.Release(); } } }
} // End Sub ListAllBranches // https://stackoverflow.com/questions/15822544/jgit-how-to-get-all-commits-of-a-branch-without-changes-to-the-working-direct public static void WalkCommits() { string dir = GetRepoPath(); Git git = Git.Open(dir); Repository repo = git.GetRepository(); RevWalk walk = new RevWalk(repo); System.Collections.Generic.IList<Ref> branches = git.BranchList().Call(); // https://stackoverflow.com/questions/15822544/jgit-how-to-get-all-commits-of-a-branch-without-changes-to-the-working-direct foreach (Ref branch in branches) { string branchName = branch.GetName(); System.Console.WriteLine("Commits of branch: " + branchName); System.Console.WriteLine("-------------------------------------"); Sharpen.Iterable<RevCommit> commits = git.Log().All().Call(); foreach (RevCommit commit in commits) { bool foundInThisBranch = false; RevCommit targetCommit = walk.ParseCommit(repo.Resolve(commit.Name)); foreach (System.Collections.Generic.KeyValuePair<string, Ref> e in repo.GetAllRefs()) { if (e.Key.StartsWith(Constants.R_HEADS)) { if (walk.IsMergedInto(targetCommit, walk.ParseCommit(e.Value.GetObjectId()))) { string foundInBranch = e.Value.GetName(); if (branchName.Equals(foundInBranch)) { foundInThisBranch = true; break; } // End if (branchName.Equals(foundInBranch)) } // End if (walk.IsMergedInto(targetCommit, walk.ParseCommit(e.Value.GetObjectId()))) } // End if (e.Key.StartsWith(Constants.R_HEADS)) } // Next e if (foundInThisBranch) { System.Console.WriteLine(commit.Name); System.Console.WriteLine(commit.GetAuthorIdent().GetName()); // System.DateTime dt = new System.DateTime(commit.CommitTime); System.DateTime dt = UnixTimeStampToDateTime(commit.CommitTime); System.Console.WriteLine(dt); System.Console.WriteLine(commit.GetFullMessage()); } // End if (foundInThisBranch) } // Next commit } // Next branch // Handle disposing of NGit's locks repo.Close(); repo.ObjectDatabase.Close(); repo = null; git = null; } // End Sub
/// <exception cref="NGit.Errors.TransportException"></exception> private IDictionary <string, RemoteRefUpdate> PrepareRemoteUpdates() { IDictionary <string, RemoteRefUpdate> result = new Dictionary <string, RemoteRefUpdate >(); foreach (RemoteRefUpdate rru in toPush.Values) { Ref advertisedRef = connection.GetRef(rru.GetRemoteName()); ObjectId advertisedOld = (advertisedRef == null ? ObjectId.ZeroId : advertisedRef .GetObjectId()); if (rru.GetNewObjectId().Equals(advertisedOld)) { if (rru.IsDelete()) { // ref does exist neither locally nor remotely rru.SetStatus(RemoteRefUpdate.Status.NON_EXISTING); } else { // same object - nothing to do rru.SetStatus(RemoteRefUpdate.Status.UP_TO_DATE); } continue; } // caller has explicitly specified expected old object id, while it // has been changed in the mean time - reject if (rru.IsExpectingOldObjectId() && !rru.GetExpectedOldObjectId().Equals(advertisedOld )) { rru.SetStatus(RemoteRefUpdate.Status.REJECTED_REMOTE_CHANGED); continue; } // create ref (hasn't existed on remote side) and delete ref // are always fast-forward commands, feasible at this level if (advertisedOld.Equals(ObjectId.ZeroId) || rru.IsDelete()) { rru.SetFastForward(true); result.Put(rru.GetRemoteName(), rru); continue; } // check for fast-forward: // - both old and new ref must point to commits, AND // - both of them must be known for us, exist in repository, AND // - old commit must be ancestor of new commit bool fastForward = true; try { RevObject oldRev = walker.ParseAny(advertisedOld); RevObject newRev = walker.ParseAny(rru.GetNewObjectId()); if (!(oldRev is RevCommit) || !(newRev is RevCommit) || !walker.IsMergedInto((RevCommit )oldRev, (RevCommit)newRev)) { fastForward = false; } } catch (MissingObjectException) { fastForward = false; } catch (Exception x) { throw new TransportException(transport.GetURI(), MessageFormat.Format(JGitText.Get ().readingObjectsFromLocalRepositoryFailed, x.Message), x); } rru.SetFastForward(fastForward); if (!fastForward && !rru.IsForceUpdate()) { rru.SetStatus(RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD); } else { result.Put(rru.GetRemoteName(), rru); } } return(result); }
/// <exception cref="NGit.Api.Errors.RefNotFoundException"></exception> /// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.NoHeadException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> private RebaseResult InitFilesAndRewind() { // we need to store everything into files so that we can implement // --skip, --continue, and --abort Ref head = repo.GetRef(Constants.HEAD); if (head == null || head.GetObjectId() == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } string headName; if (head.IsSymbolic()) { headName = head.GetTarget().GetName(); } else { headName = "detached HEAD"; } ObjectId headId = head.GetObjectId(); if (headId == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } RevCommit headCommit = walk.LookupCommit(headId); RevCommit upstream = walk.LookupCommit(upstreamCommit.Id); if (walk.IsMergedInto(upstream, headCommit)) { return(RebaseResult.UP_TO_DATE_RESULT); } else { if (walk.IsMergedInto(headCommit, upstream)) { // head is already merged into upstream, fast-foward monitor.BeginTask(MessageFormat.Format(JGitText.Get().resettingHead, upstreamCommit .GetShortMessage()), ProgressMonitor.UNKNOWN); CheckoutCommit(upstreamCommit); monitor.EndTask(); UpdateHead(headName, upstreamCommit); return(RebaseResult.FAST_FORWARD_RESULT); } } monitor.BeginTask(JGitText.Get().obtainingCommitsForCherryPick, ProgressMonitor.UNKNOWN ); // determine the commits to be applied LogCommand cmd = new Git(repo).Log().AddRange(upstreamCommit, headCommit); Iterable <RevCommit> commitsToUse = cmd.Call(); IList <RevCommit> cherryPickList = new AList <RevCommit>(); foreach (RevCommit commit in commitsToUse) { if (commit.ParentCount != 1) { throw new JGitInternalException(JGitText.Get().canOnlyCherryPickCommitsWithOneParent ); } cherryPickList.AddItem(commit); } Sharpen.Collections.Reverse(cherryPickList); // create the folder for the meta information FileUtils.Mkdir(rebaseDir); CreateFile(repo.Directory, Constants.ORIG_HEAD, headId.Name); CreateFile(rebaseDir, REBASE_HEAD, headId.Name); CreateFile(rebaseDir, HEAD_NAME, headName); CreateFile(rebaseDir, ONTO, upstreamCommit.Name); CreateFile(rebaseDir, INTERACTIVE, string.Empty); BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream (new FilePath(rebaseDir, GIT_REBASE_TODO)), Constants.CHARACTER_ENCODING)); fw.Write("# Created by EGit: rebasing " + upstreamCommit.Name + " onto " + headId .Name); fw.NewLine(); try { StringBuilder sb = new StringBuilder(); ObjectReader reader = walk.GetObjectReader(); foreach (RevCommit commit_1 in cherryPickList) { sb.Length = 0; sb.Append(RebaseCommand.Action.PICK.ToToken()); sb.Append(" "); sb.Append(reader.Abbreviate(commit_1).Name); sb.Append(" "); sb.Append(commit_1.GetShortMessage()); fw.Write(sb.ToString()); fw.NewLine(); } } finally { fw.Close(); } monitor.EndTask(); // we rewind to the upstream commit monitor.BeginTask(MessageFormat.Format(JGitText.Get().rewinding, upstreamCommit.GetShortMessage ()), ProgressMonitor.UNKNOWN); bool checkoutOk = false; try { checkoutOk = CheckoutCommit(upstreamCommit); } finally { if (!checkoutOk) { FileUtils.Delete(rebaseDir, FileUtils.RECURSIVE); } } monitor.EndTask(); return(null); }