private void PendChangesToWorkspace(string head, TfsChangesetInfo parentChangeset, ITfsWorkspace workspace) { foreach (var change in Repository.GetChangedFiles(parentChangeset.GitCommit, head)) { change.Apply(workspace); } }
public int Checkin(string head, string parent, TfsChangesetInfo parentChangeset, CheckinOptions options, string sourceTfsPath = null) { var changeset = 0; WithWorkspace(parentChangeset, workspace => changeset = Checkin(head, parent, workspace, options, sourceTfsPath)); return(changeset); }
public IGitTfsRemote CreateRemote(TfsChangesetInfo changeset) { IGitTfsRemote remote; if (changeset.Remote.IsDerived) { var remoteId = GetRemoteId(changeset); remote = _globals.Repository.CreateTfsRemote(new RemoteInfo { Id = remoteId, Url = changeset.Remote.TfsUrl, Repository = changeset.Remote.TfsRepositoryPath, RemoteOptions = _remoteOptions, }, string.Empty); remote.UpdateTfsHead(changeset.GitCommit, changeset.ChangesetId); Trace.TraceInformation("-> new remote '" + remote.Id + "'"); } else { remote = changeset.Remote; if (changeset.Remote.MaxChangesetId < changeset.ChangesetId) { int oldChangeset = changeset.Remote.MaxChangesetId; _globals.Repository.MoveTfsRefForwardIfNeeded(changeset.Remote); Trace.TraceInformation("-> existing remote {0} (updated from changeset {1})", changeset.Remote.Id, oldChangeset); } else { Trace.TraceInformation("-> existing remote {0} (up to date)", changeset.Remote.Id); } } return(remote); }
public long Checkin(string head, string parent, TfsChangesetInfo parentChangeset, CheckinOptions options) { var changeset = 0L; WithWorkspace(parentChangeset, workspace => changeset = Checkin(head, parent, workspace, options)); return(changeset); }
private string GetRemoteId(TfsChangesetInfo changeset) { if (IsAvailable(GitTfsConstants.DefaultRepositoryId)) { Trace.TraceInformation("info: '" + changeset.Remote.TfsRepositoryPath + "' will be bootstraped as your main remote..."); return(GitTfsConstants.DefaultRepositoryId); } //Remove '$/'! var expectedRemoteId = changeset.Remote.TfsRepositoryPath.Substring(2).Trim('/'); var indexOfSlash = expectedRemoteId.IndexOf('/'); if (indexOfSlash != 0) { expectedRemoteId = expectedRemoteId.Substring(indexOfSlash + 1); } var remoteId = expectedRemoteId.ToGitRefName(); var suffix = 0; while (!IsAvailable(remoteId)) { remoteId = expectedRemoteId + "-" + (suffix++); } return(remoteId); }
public int CheckinTool(string head, TfsChangesetInfo parentChangeset) { var changeset = 0; WithWorkspace(parentChangeset, workspace => changeset = CheckinTool(head, parentChangeset, workspace)); return(changeset); }
public IGitTfsRemote CreateRemote(TfsChangesetInfo changeset) { IGitTfsRemote remote; if (changeset.Remote.IsDerived) { var remoteId = GetRemoteId(changeset); remote = _globals.Repository.CreateTfsRemote(new RemoteInfo { Id = remoteId, Url = changeset.Remote.TfsUrl, Repository = changeset.Remote.TfsRepositoryPath, RemoteOptions = _remoteOptions, }, string.Empty); remote.UpdateTfsHead(changeset.GitCommit, changeset.ChangesetId); _stdout.WriteLine("-> new remote '" + remote.Id + "'"); } else { remote = changeset.Remote; if (changeset.Remote.MaxChangesetId < changeset.ChangesetId) { int oldChangeset = changeset.Remote.MaxChangesetId; _globals.Repository.MoveTfsRefForwardIfNeeded(changeset.Remote); _stdout.WriteLine("-> existing remote {0} (updated from changeset {1})", changeset.Remote.Id, oldChangeset); } else { _stdout.WriteLine("-> existing remote {0} (up to date)", changeset.Remote.Id); } } return remote; }
public long Checkin(string head, TfsChangesetInfo parentChangeset, CheckinOptions options) { var changeset = 0L; Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, workspace => changeset = Checkin(head, parentChangeset.GitCommit, workspace, options)); return(changeset); }
public long Checkin(string head, TfsChangesetInfo parentChangeset) { var changeset = 0L; Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, workspace => changeset = Checkin(head, parentChangeset, workspace)); return(changeset); }
public TfsWorkspace(Workspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote) { _workspace = workspace; _contextVersion = contextVersion; _remote = remote; _localDirectory = localDirectory; _stdout = stdout; }
protected override long DoCheckin(TfsChangesetInfo changeset, string refToCheckin) { if (!changeset.Remote.Tfs.CanPerformGatedCheckin && _checkinOptions.QueueBuildForGatedCheckIn) throw new GitTfsException( "gated checkin does not work with this TFS version (" + changeset.Remote.Tfs.TfsClientLibraryVersion + ").", new[] { "Try installing the VS2010 edition of Team Explorer." }); return changeset.Remote.Checkin(refToCheckin, changeset); }
protected override int DoCheckin(TfsChangesetInfo changeset, string refToCheckin) { if (!changeset.Remote.Tfs.CanShowCheckinDialog) throw new GitTfsException( "checkintool does not work with this TFS version (" + changeset.Remote.Tfs.TfsClientLibraryVersion + ").", new[] { "Try installing the VS2010 edition of Team Explorer." }); return changeset.Remote.CheckinTool(refToCheckin, changeset); }
public void ShouldFailWithMoreThanOneParents() { mocks.Get<Globals>().Repository = mocks.Get<IGitRepository>(); var parentChangesets = new TfsChangesetInfo() {Remote = mocks.Get<IGitTfsRemote>()}; mocks.Get<IGitRepository>().Stub(x => x.GetParentTfsCommits("my-head")) .Return(new[] {parentChangesets, parentChangesets}); Assert.AreNotEqual(GitTfsExitCodes.OK, mocks.ClassUnderTest.MakeArgsAndRun("don't care", "my-head")); }
private int PerformRCheckin(TfsChangesetInfo parentChangeset) { var tfsRemote = parentChangeset.Remote; var repo = tfsRemote.Repository; if (repo.WorkingCopyHasUnstagedOrUncommitedChanges) { throw new GitTfsException("error: You have local changes; rebase-workflow checkin only possible with clean working directory.") .WithRecommendation("Try 'git stash' to stash your local changes and checkin again."); } // get latest changes from TFS to minimize possibility of late conflict _stdout.WriteLine("Fetching changes from TFS to minimize possibility of late conflict..."); parentChangeset.Remote.Fetch(); if (parentChangeset.ChangesetId != parentChangeset.Remote.MaxChangesetId) { throw new GitTfsException("error: New TFS changesets were found.") .WithRecommendation("Try to rebase HEAD onto latest TFS checkin and repeat rcheckin or alternatively checkin s"); } string tfsLatest = parentChangeset.Remote.MaxCommitHash; // we could rcheckin only if tfsLatest changeset is a parent of HEAD // so that we could rebase after each single checkin without conflicts if (!String.IsNullOrWhiteSpace(repo.CommandOneline("rev-list", tfsLatest, "^HEAD"))) throw new GitTfsException("error: latest TFS commit should be parent of commits being checked in"); while (true) { // determine first descendant of tfsLatest string revList = repo.CommandOneline("rev-list", "--abbrev-commit", "--parents", "--ancestry-path", "--first-parent", "--reverse", tfsLatest + "..HEAD"); if (String.IsNullOrWhiteSpace(revList)) { _stdout.WriteLine("No more to rcheckin."); return GitTfsExitCodes.OK; } string[] strs = revList.Split(' '); string target = strs[0]; string[] gitParents = strs.AsEnumerable().Skip(1).Where(hash => hash != tfsLatest).ToArray(); string commitMessage = repo.GetCommitMessage(target, tfsLatest).Trim(' ', '\r', '\n'); _stdout.WriteLine("Starting checkin of {0} '{1}'", target, commitMessage); _checkinOptions.CheckinComment = commitMessage; long newChangesetId = tfsRemote.Checkin(target, parentChangeset); tfsRemote.FetchWithMerge(newChangesetId, gitParents); if (tfsRemote.MaxChangesetId != newChangesetId) throw new GitTfsException("error: New TFS changesets were found. Rcheckin was not finished."); tfsLatest = tfsRemote.MaxCommitHash; parentChangeset = new TfsChangesetInfo {ChangesetId = newChangesetId, GitCommit = tfsLatest, Remote = tfsRemote}; _stdout.WriteLine("Done with {0}, rebasing tail onto new TFS-commit...", target); repo.CommandNoisy("rebase", "--preserve-merges", "--onto", tfsLatest, target); _stdout.WriteLine("Rebase done successfully."); } }
public TfsWorkspace(IWorkspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote, CheckinOptions checkinOptions, ITfsHelper tfsHelper) { _workspace = workspace; _contextVersion = contextVersion; _remote = remote; _checkinOptions = checkinOptions; _tfsHelper = tfsHelper; _localDirectory = localDirectory; _stdout = stdout; }
private void WithWorkspace(TfsChangesetInfo parentChangeset, Action <ITfsWorkspace> action) { // If there isn't a custom workspace, and a workspace is lingering from a previous // git-tfs run, clean it up. If the user is using a custom workspace dir, leave // it for them to explicitly clean up, in case they're doing something unsupported // with it. Tfs.CleanupWorkspaces(DefaultWorkingDirectory); Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, action); }
public TfsWorkspace(IWorkspace workspace, string localDirectory, TfsChangesetInfo contextVersion, IGitTfsRemote remote, CheckinOptions checkinOptions, ITfsHelper tfsHelper, CheckinPolicyEvaluator policyEvaluator) { _workspace = workspace; _policyEvaluator = policyEvaluator; _contextVersion = contextVersion; _checkinOptions = checkinOptions; _tfsHelper = tfsHelper; _localDirectory = remote.Repository.IsBare ? Path.GetFullPath(localDirectory) : localDirectory; this.Remote = remote; }
public TfsWorkspace(IWorkspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote, CheckinOptions checkinOptions, ITfsHelper tfsHelper, CheckinPolicyEvaluator policyEvaluator) { _workspace = workspace; _policyEvaluator = policyEvaluator; _contextVersion = contextVersion; _remote = remote; _checkinOptions = checkinOptions; _tfsHelper = tfsHelper; _localDirectory = localDirectory; _stdout = stdout; }
private string GetRemoteId(TfsChangesetInfo parent) { if (IsAvailable(GitTfsConstants.DefaultRepositoryId)) return GitTfsConstants.DefaultRepositoryId; var hostname = new Uri(parent.Remote.TfsUrl).Host.Replace(".", "-"); var remoteId = hostname; var suffix = 0; while (!IsAvailable(remoteId)) remoteId = hostname + "-" + (suffix++); return remoteId; }
private void WithWorkspace(TfsChangesetInfo parentChangeset, Action <ITfsWorkspace> action) { //are there any subtrees? var subtrees = globals.Repository.GetSubtrees(this); if (subtrees.Any()) { Tfs.WithWorkspace(WorkingDirectory, this, subtrees.Select(x => new Tuple <string, string>(x.TfsRepositoryPath, x.Prefix)), parentChangeset, action); } else { Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, action); } }
private int PerformCheckin(TfsChangesetInfo parentChangeset, string refToCheckin) { var newChangesetId = DoCheckin(parentChangeset, refToCheckin); if (_checkinOptions.NoMerge) { _stdout.WriteLine("TFS Changeset #" + newChangesetId + " was created."); parentChangeset.Remote.Fetch(); } else { _stdout.WriteLine("TFS Changeset #" + newChangesetId + " was created. Marking it as a merge commit..."); parentChangeset.Remote.FetchWithMerge(newChangesetId, refToCheckin); if (refToCheckin == "HEAD") parentChangeset.Remote.Repository.CommandNoisy("merge", parentChangeset.Remote.MaxCommitHash); } return GitTfsExitCodes.OK; }
private string GetRemoteId(TfsChangesetInfo changeset) { if (IsAvailable(GitTfsConstants.DefaultRepositoryId)) { _stdout.WriteLine("info: '" + changeset.Remote.TfsRepositoryPath + "' will be bootstraped as your main remote..."); return GitTfsConstants.DefaultRepositoryId; } //Remove '$/'! var expectedRemoteId = changeset.Remote.TfsRepositoryPath.Substring(2).Trim('/'); var indexOfSlash = expectedRemoteId.IndexOf('/'); if (indexOfSlash != 0) expectedRemoteId = expectedRemoteId.Substring(indexOfSlash + 1); var remoteId = expectedRemoteId.ToGitRefName(); var suffix = 0; while (!IsAvailable(remoteId)) remoteId = expectedRemoteId + "-" + (suffix++); return remoteId; }
private int PerformRCheckin(TfsChangesetInfo parentChangeset, string refToCheckin) { if (_globals.Repository.IsBare) AutoRebase = false; if (_globals.Repository.WorkingCopyHasUnstagedOrUncommitedChanges) { throw new GitTfsException("error: You have local changes; rebase-workflow checkin only possible with clean working directory.") .WithRecommendation("Try 'git stash' to stash your local changes and checkin again."); } // get latest changes from TFS to minimize possibility of late conflict _stdout.WriteLine("Fetching changes from TFS to minimize possibility of late conflict..."); parentChangeset.Remote.Fetch(); if (parentChangeset.ChangesetId != parentChangeset.Remote.MaxChangesetId) { if (AutoRebase) { _globals.Repository.CommandNoisy("rebase", "--preserve-merges", parentChangeset.Remote.RemoteRef); parentChangeset = _globals.Repository.GetTfsCommit(parentChangeset.Remote.MaxCommitHash); } else { if (_globals.Repository.IsBare) _globals.Repository.UpdateRef(refToCheckin, parentChangeset.Remote.MaxCommitHash); throw new GitTfsException("error: New TFS changesets were found.") .WithRecommendation("Try to rebase HEAD onto latest TFS checkin and repeat rcheckin or alternatively checkins"); } } IEnumerable<GitCommit> commitsToCheckin = _globals.Repository.FindParentCommits(refToCheckin, parentChangeset.Remote.MaxCommitHash); Trace.WriteLine("Commit to checkin count:" + commitsToCheckin.Count()); if (!commitsToCheckin.Any()) throw new GitTfsException("error: latest TFS commit should be parent of commits being checked in"); SetupMetadataExport(parentChangeset.Remote); return _PerformRCheckinQuick(parentChangeset, refToCheckin, commitsToCheckin); }
private int PerformRCheckin(TfsChangesetInfo parentChangeset, string refToCheckin) { if (_globals.Repository.IsBare) AutoRebase = false; if (_globals.Repository.WorkingCopyHasUnstagedOrUncommitedChanges) { throw new GitTfsException("error: You have local changes; rebase-workflow checkin only possible with clean working directory.") .WithRecommendation("Try 'git stash' to stash your local changes and checkin again."); } // get latest changes from TFS to minimize possibility of late conflict _stdout.WriteLine("Fetching changes from TFS to minimize possibility of late conflict..."); parentChangeset.Remote.Fetch(); if (parentChangeset.ChangesetId != parentChangeset.Remote.MaxChangesetId) { if (!Old && AutoRebase) { _globals.Repository.CommandNoisy("rebase", "--preserve-merges", parentChangeset.Remote.RemoteRef); parentChangeset = _globals.Repository.GetTfsCommit(parentChangeset.Remote.MaxCommitHash); } else { if (_globals.Repository.IsBare) _globals.Repository.UpdateRef(refToCheckin, parentChangeset.Remote.MaxCommitHash); throw new GitTfsException("error: New TFS changesets were found.") .WithRecommendation("Try to rebase HEAD onto latest TFS checkin and repeat rcheckin or alternatively checkin s"); } } string tfsLatest = parentChangeset.Remote.MaxCommitHash; // we could rcheckin only if tfsLatest changeset is a parent of HEAD // so that we could rebase after each single checkin without conflicts if (!String.IsNullOrWhiteSpace(_globals.Repository.CommandOneline("rev-list", tfsLatest, "^" + refToCheckin))) throw new GitTfsException("error: latest TFS commit should be parent of commits being checked in"); return (!Old || _globals.Repository.IsBare) ? _PerformRCheckinQuick(parentChangeset, refToCheckin) : _PerformRCheckin(parentChangeset, refToCheckin); }
private int PerformCheckin(TfsChangesetInfo parentChangeset, string refToCheckin) { var newChangesetId = DoCheckin(parentChangeset, refToCheckin); if (_checkinOptions.NoMerge) { _stdout.WriteLine("TFS Changeset #" + newChangesetId + " was created."); parentChangeset.Remote.Fetch(); } else { _stdout.WriteLine("TFS Changeset #" + newChangesetId + " was created. Marking it as a merge commit..."); parentChangeset.Remote.FetchWithMerge(newChangesetId, false, refToCheckin); if (refToCheckin == "HEAD") parentChangeset.Remote.Repository.Merge(parentChangeset.Remote.MaxCommitHash); } Trace.WriteLine("Cleaning..."); parentChangeset.Remote.CleanupWorkspaceDirectory(); return GitTfsExitCodes.OK; }
public int Verify(TfsChangesetInfo changeset, bool ignorePathCaseMismatch) { Trace.TraceInformation("Comparing TFS changeset " + changeset.ChangesetId + " to git commit " + changeset.GitCommit); var tfsTree = changeset.Remote.GetChangeset(changeset.ChangesetId).GetTree().ToDictionary(entry => entry.FullName.ToLowerInvariant().Replace("/", @"\")); var gitTree = changeset.Remote.Repository.GetCommit(changeset.GitCommit).GetTree().ToDictionary(entry => entry.Entry.Path.ToLowerInvariant()); var all = tfsTree.Keys.Union(gitTree.Keys); var inBoth = tfsTree.Keys.Intersect(gitTree.Keys); var tfsOnly = tfsTree.Keys.Except(gitTree.Keys); var gitOnly = gitTree.Keys.Except(tfsTree.Keys); var foundDiff = GitTfsExitCodes.OK; foreach (var file in all.OrderBy(x => x)) { if (tfsTree.ContainsKey(file)) { if (gitTree.ContainsKey(file)) { if (Compare(tfsTree[file], gitTree[file], ignorePathCaseMismatch)) foundDiff = Math.Max(foundDiff, GitTfsExitCodes.VerifyContentMismatch); } else { Trace.TraceInformation("Only in TFS: " + tfsTree[file].FullName); foundDiff = Math.Max(foundDiff, GitTfsExitCodes.VerifyFileMissing); } } else { Trace.TraceInformation("Only in git: " + gitTree[file].FullName); foundDiff = Math.Max(foundDiff, GitTfsExitCodes.VerifyFileMissing); } } if (foundDiff == GitTfsExitCodes.OK) Trace.TraceInformation("No differences!"); return foundDiff; }
private void FindTfsCommits(TextReader stdout, ICollection <TfsChangesetInfo> tfsCommits, bool includeStubRemotes) { string currentCommit = null; TfsChangesetInfo lastChangesetInfo = null; string line; while (null != (line = stdout.ReadLine())) { var match = GitTfsConstants.CommitRegex.Match(line); if (match.Success) { if (lastChangesetInfo != null) { tfsCommits.Add(lastChangesetInfo); lastChangesetInfo = null; } currentCommit = match.Groups[1].Value; continue; } var changesetInfo = TryParseChangesetInfo(line, currentCommit, includeStubRemotes); if (changesetInfo != null) { lastChangesetInfo = changesetInfo; } } // Add the final changesetinfo object; it won't be handled in the loop // if it was part of the last commit message. if (lastChangesetInfo != null) { tfsCommits.Add(lastChangesetInfo); } //stdout.Close(); }
public void Verify(TfsChangesetInfo changeset) { _stdout.WriteLine("Comparing TFS changeset " + changeset.ChangesetId + " to git commit " + changeset.GitCommit); var tfsTree = changeset.Remote.GetChangeset(changeset.ChangesetId).GetTree().ToDictionary(entry => entry.FullName.ToLowerInvariant().Replace("/",@"\")); var gitTree = changeset.Remote.Repository.GetCommit(changeset.GitCommit).GetTree().ToDictionary(entry => entry.Entry.Path.ToLowerInvariant()); var all = tfsTree.Keys.Union(gitTree.Keys); var inBoth = tfsTree.Keys.Intersect(gitTree.Keys); var tfsOnly = tfsTree.Keys.Except(gitTree.Keys); var gitOnly = gitTree.Keys.Except(tfsTree.Keys); var foundDiff = false; foreach(var file in all.OrderBy(x => x)) { if(tfsTree.ContainsKey(file)) { if(gitTree.ContainsKey(file)) { if (Compare(tfsTree[file], gitTree[file])) foundDiff = true; } else { _stdout.WriteLine("Only in TFS: " + tfsTree[file].FullName); foundDiff = true; } } else { _stdout.WriteLine("Only in git: " + gitTree[file].FullName); foundDiff = true; } } if(!foundDiff) _stdout.WriteLine("No differences!"); }
public long CheckinTool(string head, TfsChangesetInfo parentChangeset) { throw new NotImplementedException(); }
public int CheckinTool(string head, TfsChangesetInfo parentChangeset) { throw DerivedRemoteException; }
public void Shelve(string shelvesetName, string head, TfsChangesetInfo parentChangeset, bool evaluateCheckinPolicies) { Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, workspace => Shelve(shelvesetName, head, parentChangeset, evaluateCheckinPolicies, workspace)); }
private void Shelve(string shelvesetName, string head, TfsChangesetInfo parentChangeset, bool evaluateCheckinPolicies, ITfsWorkspace workspace) { PendChangesToWorkspace(head, parentChangeset.GitCommit, workspace); workspace.Shelve(shelvesetName, evaluateCheckinPolicies, () => Repository.GetCommitMessage(head, parentChangeset.GitCommit)); }
private int _PerformRCheckin(TfsChangesetInfo parentChangeset, string refToCheckin) { var tfsRemote = parentChangeset.Remote; var repo = tfsRemote.Repository; string tfsLatest = parentChangeset.Remote.MaxCommitHash; RCheckinCommit rc = new RCheckinCommit(repo); while (true) { // determine first descendant of tfsLatest string revList = repo.CommandOneline("rev-list", "--parents", "--ancestry-path", "--first-parent", "--reverse", tfsLatest + ".." + refToCheckin); if (String.IsNullOrWhiteSpace(revList)) { _stdout.WriteLine("No more to rcheckin."); Trace.WriteLine("Cleaning..."); tfsRemote.CleanupWorkspaceDirectory(); return GitTfsExitCodes.OK; } rc.ExtractCommit(revList, tfsLatest); rc.BuildCommitMessage(!_checkinOptions.NoGenerateCheckinComment, tfsLatest); string target = rc.Sha; string tfsRepositoryPathOfMergedBranch = FindTfsRepositoryPathOfMergedBranch(tfsRemote, rc.Parents, target); var commitSpecificCheckinOptions = _checkinOptionsFactory.BuildCommitSpecificCheckinOptions(_checkinOptions, rc.Message, rc.Commit); _stdout.WriteLine("Starting checkin of {0} '{1}'", target.Substring(0, 8), commitSpecificCheckinOptions.CheckinComment); long newChangesetId = tfsRemote.Checkin(rc.Sha, parentChangeset, commitSpecificCheckinOptions, tfsRepositoryPathOfMergedBranch); tfsRemote.FetchWithMerge(newChangesetId, false, rc.Parents); if (tfsRemote.MaxChangesetId != newChangesetId) throw new GitTfsException("error: New TFS changesets were found. Rcheckin was not finished."); tfsLatest = tfsRemote.MaxCommitHash; parentChangeset = new TfsChangesetInfo {ChangesetId = newChangesetId, GitCommit = tfsLatest, Remote = tfsRemote}; _stdout.WriteLine("Done with {0}, rebasing tail onto new TFS-commit...", target); RebaseOnto(repo, tfsLatest, target); _stdout.WriteLine("Rebase done successfully."); } }
public long Checkin(string head, string parent, TfsChangesetInfo parentChangeset, CheckinOptions options) { throw new NotImplementedException(); }
private void WithWorkspace(TfsChangesetInfo parentChangeset, Action<ITfsWorkspace> action) { //are there any subtrees? var subtrees = globals.Repository.GetSubtrees(this); if (subtrees.Any()) { Tfs.WithWorkspace(WorkingDirectory, this, subtrees.Select(x => new Tuple<string, string>(x.TfsRepositoryPath, x.Prefix)), parentChangeset, action); } else { Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, action); } }
public int CheckinTool(string head, TfsChangesetInfo parentChangeset) { var changeset = 0; WithWorkspace(parentChangeset, workspace => changeset = CheckinTool(head, parentChangeset, workspace)); return changeset; }
public void CreateTfsRemote(string remoteId, TfsChangesetInfo tfsHead, RemoteOptions remoteOptions) { CreateTfsRemote(remoteId, tfsHead.Remote.TfsUrl, tfsHead.Remote.TfsRepositoryPath, remoteOptions); ReadTfsRemote(remoteId).UpdateRef(tfsHead.GitCommit, tfsHead.ChangesetId); }
public void Shelve(string shelvesetName, string treeish, TfsChangesetInfo parentChangeset, CheckinOptions options, bool evaluateCheckinPolicies) { throw DerivedRemoteException; }
public long Checkin(string head, string parent, TfsChangesetInfo parentChangeset, CheckinOptions options, string sourceTfsPath = null) { throw DerivedRemoteException; }
public long CheckinTool(string head, TfsChangesetInfo parentChangeset) { throw DerivedRemoteException; }
public void Shelve(string shelvesetName, string treeish, TfsChangesetInfo parentChangeset, bool evaluateCheckinPolicies) { throw DerivedRemoteException; }
private long Checkin(string head, TfsChangesetInfo parentChangeset, ITfsWorkspace workspace) { PendChangesToWorkspace(head, parentChangeset, workspace); return(workspace.Checkin()); }
protected abstract int DoCheckin(TfsChangesetInfo changeset, string refToCheckin);
public void WithWorkspace(string directory, IGitTfsRemote remote, TfsChangesetInfo versionToFetch, Action<ITfsWorkspace> action) { Trace.WriteLine("Setting up a TFS workspace at " + directory); var fakeWorkspace = new FakeWorkspace(directory, remote.TfsRepositoryPath); var workspace = _container.With("localDirectory").EqualTo(directory) .With("remote").EqualTo(remote) .With("contextVersion").EqualTo(versionToFetch) .With("workspace").EqualTo(fakeWorkspace) .With("tfsHelper").EqualTo(this) .GetInstance<TfsWorkspace>(); action(workspace); }
public long Checkin(string treeish, TfsChangesetInfo parentChangeset, CheckinOptions options, string sourceTfsPath = null) { throw new NotImplementedException(); }
public int Checkin(string head, string parent, TfsChangesetInfo parentChangeset, CheckinOptions options, string sourceTfsPath = null) { var changeset = 0; WithWorkspace(parentChangeset, workspace => changeset = Checkin(head, parent, workspace, options, sourceTfsPath)); return changeset; }
public long Checkin(string treeish, TfsChangesetInfo parentChangeset) { throw new NotImplementedException(); }
private int PerformRCheckin(TfsChangesetInfo parentChangeset) { var tfsRemote = parentChangeset.Remote; var repo = tfsRemote.Repository; if (repo.WorkingCopyHasUnstagedOrUncommitedChanges) { throw new GitTfsException("error: You have local changes; rebase-workflow checkin only possible with clean working directory.") .WithRecommendation("Try 'git stash' to stash your local changes and checkin again."); } // get latest changes from TFS to minimize possibility of late conflict _stdout.WriteLine("Fetching changes from TFS to minimize possibility of late conflict..."); parentChangeset.Remote.Fetch(); if (parentChangeset.ChangesetId != parentChangeset.Remote.MaxChangesetId) { if (Quick && AutoRebase) { tfsRemote.Repository.CommandNoisy("rebase", "--preserve-merges", tfsRemote.RemoteRef); } else { throw new GitTfsException("error: New TFS changesets were found.") .WithRecommendation("Try to rebase HEAD onto latest TFS checkin and repeat rcheckin or alternatively checkin s"); } } string tfsLatest = parentChangeset.Remote.MaxCommitHash; // we could rcheckin only if tfsLatest changeset is a parent of HEAD // so that we could rebase after each single checkin without conflicts if (!String.IsNullOrWhiteSpace(repo.CommandOneline("rev-list", tfsLatest, "^HEAD"))) throw new GitTfsException("error: latest TFS commit should be parent of commits being checked in"); if (Quick) { string[] revList = null; repo.CommandOutputPipe(tr => revList = tr.ReadToEnd().Split('\n').Where(s => !String.IsNullOrWhiteSpace(s)).ToArray(), "rev-list", "--parents", "--ancestry-path", "--first-parent", "--reverse", tfsLatest + "..HEAD"); string currentParent = tfsLatest; long newChangesetId = 0; foreach (string commitWithParents in revList) { string[] strs = commitWithParents.Split(' '); string target = strs[0]; string[] gitParents = strs.AsEnumerable().Skip(1).Where(hash => hash != currentParent).ToArray(); string commitMessage = _checkinOptions.NoGenerateCheckinComment ? repo.GetCommitMessage(target) : repo.GetCommitMessage(target, currentParent); var commitSpecificCheckinOptions = _checkinOptionsFactory.BuildCommitSpecificCheckinOptions(_checkinOptions, commitMessage); _stdout.WriteLine("Starting checkin of {0} '{1}'", target.Substring(0, 8), commitSpecificCheckinOptions.CheckinComment); try { newChangesetId = tfsRemote.Checkin(target, currentParent, parentChangeset, commitSpecificCheckinOptions); tfsRemote.FetchWithMerge(newChangesetId, gitParents); if (tfsRemote.MaxChangesetId != newChangesetId) { var lastCommit = repo.FindCommitHashByCommitMessage("git-tfs-id: .*;C" + newChangesetId + "[^0-9]"); RebaseOnto(repo, lastCommit, target); if (AutoRebase) { tfsRemote.Repository.CommandNoisy("rebase", "--preserve-merges", tfsRemote.RemoteRef); } else { throw new GitTfsException("error: New TFS changesets were found. Rcheckin was not finished."); } } currentParent = target; parentChangeset = new TfsChangesetInfo { ChangesetId = newChangesetId, GitCommit = tfsRemote.MaxCommitHash, Remote = tfsRemote }; _stdout.WriteLine("Done with {0}.", target); } catch (Exception) { if (newChangesetId != 0) { var lastCommit = repo.FindCommitHashByCommitMessage("git-tfs-id: .*;C" + newChangesetId + "[^0-9]"); RebaseOnto(repo, lastCommit, currentParent); } throw; } } repo.Reset(tfsRemote.MaxCommitHash, ResetOptions.Hard); _stdout.WriteLine("No more to rcheckin."); return GitTfsExitCodes.OK; } else { while (true) { // determine first descendant of tfsLatest string revList = repo.CommandOneline("rev-list", "--parents", "--ancestry-path", "--first-parent", "--reverse", tfsLatest + "..HEAD"); if (String.IsNullOrWhiteSpace(revList)) { _stdout.WriteLine("No more to rcheckin."); return GitTfsExitCodes.OK; } string[] strs = revList.Split(' '); string target = strs[0]; string[] gitParents = strs.AsEnumerable().Skip(1).Where(hash => hash != tfsLatest).ToArray(); string commitMessage = _checkinOptions.NoGenerateCheckinComment ? repo.GetCommitMessage(target) : repo.GetCommitMessage(target, tfsLatest); var commitSpecificCheckinOptions = _checkinOptionsFactory.BuildCommitSpecificCheckinOptions(_checkinOptions, commitMessage); _stdout.WriteLine("Starting checkin of {0} '{1}'", target.Substring(0, 8), commitSpecificCheckinOptions.CheckinComment); long newChangesetId = tfsRemote.Checkin(target, parentChangeset, commitSpecificCheckinOptions); tfsRemote.FetchWithMerge(newChangesetId, gitParents); if (tfsRemote.MaxChangesetId != newChangesetId) throw new GitTfsException("error: New TFS changesets were found. Rcheckin was not finished."); tfsLatest = tfsRemote.MaxCommitHash; parentChangeset = new TfsChangesetInfo { ChangesetId = newChangesetId, GitCommit = tfsLatest, Remote = tfsRemote }; _stdout.WriteLine("Done with {0}, rebasing tail onto new TFS-commit...", target); RebaseOnto(repo, tfsLatest, target); _stdout.WriteLine("Rebase done successfully."); } } }
public void Shelve(string shelvesetName, string head, TfsChangesetInfo parentChangeset, bool evaluateCheckinPolicies) { WithWorkspace(parentChangeset, workspace => Shelve(shelvesetName, head, parentChangeset, evaluateCheckinPolicies, workspace)); }
private int _PerformRCheckinQuick(TfsChangesetInfo parentChangeset, string refToCheckin) { var tfsRemote = parentChangeset.Remote; var repo = tfsRemote.Repository; string tfsLatest = parentChangeset.Remote.MaxCommitHash; string[] revList = null; repo.CommandOutputPipe(tr => revList = tr.ReadToEnd().Split('\n').Where(s => !String.IsNullOrWhiteSpace(s)).ToArray(), "rev-list", "--parents", "--ancestry-path", "--first-parent", "--reverse", tfsLatest + ".." + refToCheckin); string currentParent = tfsLatest; long newChangesetId = 0; RCheckinCommit rc = new RCheckinCommit(repo); foreach (string commitWithParents in revList) { rc.ExtractCommit(commitWithParents, currentParent); rc.BuildCommitMessage(!_checkinOptions.NoGenerateCheckinComment, currentParent); string target = rc.Sha; string tfsRepositoryPathOfMergedBranch = FindTfsRepositoryPathOfMergedBranch(tfsRemote, rc.Parents, target); var commitSpecificCheckinOptions = _checkinOptionsFactory.BuildCommitSpecificCheckinOptions(_checkinOptions, rc.Message, rc.Commit); _stdout.WriteLine("Starting checkin of {0} '{1}'", target.Substring(0, 8), commitSpecificCheckinOptions.CheckinComment); try { newChangesetId = tfsRemote.Checkin(target, currentParent, parentChangeset, commitSpecificCheckinOptions, tfsRepositoryPathOfMergedBranch); var fetchResult = tfsRemote.FetchWithMerge(newChangesetId, false, rc.Parents); if (fetchResult.NewChangesetCount != 1) { var lastCommit = repo.FindCommitHashByChangesetId(newChangesetId); RebaseOnto(repo, lastCommit, target); if (AutoRebase) { tfsRemote.Repository.CommandNoisy("rebase", "--preserve-merges", tfsRemote.RemoteRef); } else { throw new GitTfsException("error: New TFS changesets were found. Rcheckin was not finished."); } } currentParent = target; parentChangeset = new TfsChangesetInfo {ChangesetId = newChangesetId, GitCommit = tfsRemote.MaxCommitHash, Remote = tfsRemote}; _stdout.WriteLine("Done with {0}.", target); } catch (Exception) { if (newChangesetId != 0) { var lastCommit = repo.FindCommitHashByChangesetId(newChangesetId); RebaseOnto(repo, lastCommit, currentParent); } throw; } } if (repo.IsBare) repo.UpdateRef(refToCheckin, tfsRemote.MaxCommitHash); else repo.Reset(tfsRemote.MaxCommitHash, ResetOptions.Hard); _stdout.WriteLine("No more to rcheckin."); Trace.WriteLine("Cleaning..."); tfsRemote.CleanupWorkspaceDirectory(); return GitTfsExitCodes.OK; }
public long CheckinTool(string head, TfsChangesetInfo parentChangeset) { var changeset = 0L; Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, workspace => changeset = CheckinTool(head, parentChangeset, workspace)); return changeset; }
private long CheckinTool(string head, TfsChangesetInfo parentChangeset, ITfsWorkspace workspace) { PendChangesToWorkspace(head, parentChangeset.GitCommit, workspace); return(workspace.CheckinTool(() => Repository.GetCommitMessage(head, parentChangeset.GitCommit))); }
private long CheckinTool(string head, TfsChangesetInfo parentChangeset, ITfsWorkspace workspace) { PendChangesToWorkspace(head, parentChangeset.GitCommit, workspace); return workspace.CheckinTool(() => Repository.GetCommitMessage(head, parentChangeset.GitCommit)); }
private void WithWorkspace(TfsChangesetInfo parentChangeset, Action <ITfsWorkspace> action) { Tfs.WithWorkspace(WorkingDirectory, this, parentChangeset, action); }
public int Checkin(string treeish, TfsChangesetInfo parentChangeset, CheckinOptions options, string sourceTfsPath = null) { throw DerivedRemoteException; }
public void Shelve(string shelvesetName, string treeish, TfsChangesetInfo parentChangeset, bool evaluateCheckinPolicies) { throw new NotImplementedException(); }
protected override int DoCheckin(TfsChangesetInfo changeset, string refToCheckin) { return changeset.Remote.Checkin(refToCheckin, changeset, _checkinOptions); }
private void Shelve(string shelvesetName, string head, TfsChangesetInfo parentChangeset, CheckinOptions options, bool evaluateCheckinPolicies, ITfsWorkspace workspace) { PendChangesToWorkspace(head, parentChangeset.GitCommit, workspace); workspace.Shelve(shelvesetName, evaluateCheckinPolicies, options); }