Exemplo n.º 1
0
        private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
        {
            var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
            var shaParent         = Repository.FindCommitHashByChangesetId(parentChangesetId);

            if (shaParent == null)
            {
                shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit);
            }
            if (shaParent != null)
            {
                parentCommit = shaParent;
            }
            else
            {
                if (stopOnFailMergeCommit)
                {
                    return(false);
                }
                //TODO : Manage case where there is not yet a git commit for the parent changset!!!!!
                stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
                                 " is a merge changeset. But it can't have been managed accordingly because one of the parent changeset "
                                 + parentChangesetId +
                                 " is not present in the repository! If you want to do it, fetch the branch containing this changeset before retrying...");
            }
            return(true);
        }
Exemplo n.º 2
0
        private bool ProcessMergeChangeset(ITfsChangeset changeset, bool stopOnFailMergeCommit, ref string parentCommit)
        {
            if (!Tfs.CanGetBranchInformation)
            {
                stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
                                 " is a merge changeset. But was not treated as is because this version of TFS can't manage branches...");
            }
            else if (!IsIgnoringBranches())
            {
                var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
                if (parentChangesetId < 1)  // Handle missing merge parent info
                {
                    if (stopOnFailMergeCommit)
                    {
                        return(false);
                    }

                    stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId + " is a merge changeset. But git-tfs is unable to determine the parent changeset.");
                    return(true);
                }

                var shaParent = Repository.FindCommitHashByChangesetId(parentChangesetId);
                if (shaParent == null)
                {
                    string omittedParentBranch;
                    shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit, out omittedParentBranch);
                    changeset.OmittedParentBranch = omittedParentBranch;
                }

                if (shaParent != null)
                {
                    parentCommit = shaParent;
                }
                else
                {
                    if (stopOnFailMergeCommit)
                    {
                        return(false);
                    }

                    stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
                                     " is a merge changeset. But git-tfs failed to find and fetch the parent changeset "
                                     + parentChangesetId + ". Parent changeset will be ignored...");
                }
            }
            else
            {
                stdout.WriteLine("info: this changeset " + changeset.Summary.ChangesetId +
                                 " is a merge changeset. But was not treated as is because of your git setting...");
                changeset.OmittedParentBranch = ";C" + changeset.Summary.ChangesetId;
            }
            return(true);
        }
Exemplo n.º 3
0
        public IFetchResult FetchWithMerge(long mergeChangesetId, bool stopOnFailMergeCommit = false, params string[] parentCommitsHashes)
        {
            var fetchResult = new FetchResult {
                IsSuccess = true
            };

            foreach (var changeset in FetchChangesets())
            {
                AssertTemporaryIndexClean(MaxCommitHash);
                var log = Apply(MaxCommitHash, changeset);
                if (changeset.IsMergeChangeset)
                {
                    var parentChangesetId = Tfs.FindMergeChangesetParent(TfsRepositoryPath, changeset.Summary.ChangesetId, this);
                    var shaParent         = Repository.FindCommitHashByChangesetId(parentChangesetId);
                    if (shaParent == null)
                    {
                        shaParent = FindMergedRemoteAndFetch(parentChangesetId, stopOnFailMergeCommit);
                    }
                    if (shaParent != null)
                    {
                        log.CommitParents.Add(shaParent);
                    }
                    else
                    {
                        if (stopOnFailMergeCommit)
                        {
                            fetchResult.IsSuccess = false;
                            fetchResult.LastFetchedChangesetId = MaxChangesetId;
                            return(fetchResult);
                        }
//TODO : Manage case where there is not yet a git commit for the parent changset!!!!!
                        stdout.WriteLine("warning: this changeset " + changeset.Summary.ChangesetId +
                                         " is a merge changeset. But it can't have been managed accordingly because one of the parent changeset "
                                         + parentChangesetId + " is not present in the repository! If you want to do it, fetch the branch containing this changeset before retrying...");
                    }
                }
                if (changeset.Summary.ChangesetId == mergeChangesetId)
                {
                    foreach (var parent in parentCommitsHashes)
                    {
                        log.CommitParents.Add(parent);
                    }
                }

                if (ExportMetadatas)
                {
                    if (changeset.Summary.Workitems.Any())
                    {
                        string workitems = string.Empty;
                        foreach (var workitem in changeset.Summary.Workitems)
                        {
                            workitems += "\n" + GitTfsConstants.GitTfsWorkItemPrefix + workitem.Id + " associate";
                        }
                        log.Log += workitems;
                    }

                    if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
                    {
                        log.Log += "\n" + GitTfsConstants.GitTfsPolicyOverrideCommentPrefix + changeset.Summary.PolicyOverrideComment;
                    }

                    if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
                    {
                        log.Log += "\n" + GitTfsConstants.GitTfsCodeReviewerPrefix + changeset.Summary.CodeReviewer;
                    }

                    if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
                    {
                        log.Log += "\n" + GitTfsConstants.GitTfsSecurityReviewerPrefix + changeset.Summary.SecurityReviewer;
                    }

                    if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
                    {
                        log.Log += "\n" + GitTfsConstants.GitTfsPerformanceReviewerPrefix + changeset.Summary.PerformanceReviewer;
                    }
                }

                var commitSha = Commit(log);
                UpdateTfsHead(commitSha, changeset.Summary.ChangesetId);
                StringBuilder metadatas = new StringBuilder();
                if (changeset.Summary.Workitems.Any())
                {
                    string workitemNote = "Workitems:\n";
                    foreach (var workitem in changeset.Summary.Workitems)
                    {
                        workitemNote += String.Format("[{0}] {1}\n    {2}\n", workitem.Id, workitem.Title, workitem.Url);
                    }
                    metadatas.Append(workitemNote);
                }

                if (!string.IsNullOrWhiteSpace(changeset.Summary.PolicyOverrideComment))
                {
                    metadatas.Append("\nPolicy Override Comment:" + changeset.Summary.PolicyOverrideComment);
                }

                if (!string.IsNullOrWhiteSpace(changeset.Summary.CodeReviewer))
                {
                    metadatas.Append("\nCode Reviewer:" + changeset.Summary.CodeReviewer);
                }

                if (!string.IsNullOrWhiteSpace(changeset.Summary.SecurityReviewer))
                {
                    metadatas.Append("\nSecurity Reviewer:" + changeset.Summary.SecurityReviewer);
                }

                if (!string.IsNullOrWhiteSpace(changeset.Summary.PerformanceReviewer))
                {
                    metadatas.Append("\nPerformance Reviewer:" + changeset.Summary.PerformanceReviewer);
                }
                if (metadatas.Length != 0)
                {
                    Repository.CreateNote(commitSha, metadatas.ToString(), log.AuthorName, log.AuthorEmail, log.Date);
                }
                DoGcIfNeeded();
            }
            return(fetchResult);
        }