public void Equals_ChangesetAndObject_ReturnsFalse() { var set = new Changeset(); var obj = new object(); Assert.That(set.Equals(obj), Is.False); }
public void Apply(Changeset changeset) { if (!_fullPath.StartsWithIgnoreCase(_rootDirectory)) { return; } var newDirectoryInfo = _fileSystem.GetDirectoryInfo(_fullPath); var newRelativePath = PathHelper.MakeRelative(_rootDirectory, _fullPath); if (!newDirectoryInfo.Exists || !_fileSystemFilter.IsDirectoryAllowed(newRelativePath, newDirectoryInfo.Attributes)) { return; } newRelativePath = PathHelper.EnsureTrailingSlash(newRelativePath); var oldRelativePath = PathHelper.EnsureTrailingSlash(PathHelper.MakeRelative(_rootDirectory, _oldFullPath)); // If directory with the oldRelativePath was previously added, remove it from the AddedDirectories, add newRelativePath and change all its content paths: if (changeset.AddedDirectories.Contains(oldRelativePath)) { UpdatePrefix(changeset.AddedDirectories, oldRelativePath, newRelativePath); UpdatePrefix(changeset.AddedFiles, oldRelativePath, newRelativePath); return; } // if directory with the newRelativePath was previously deleted, keep both changes (delete and rename), // cause the content of the directory to be deleted is different from the content of renamed directory // if there is a directory that was renamed into oldRelativePath, rename it to newRelativePath instead // or remove from RenamedDirectories if previouslyRenamedRelativePath equal to newRelativePath var previouslyRenamedRelativePath = changeset.RenamedDirectories.GetFirstKeyByValueIgnoreCase(oldRelativePath); if (string.IsNullOrEmpty(previouslyRenamedRelativePath)) { changeset.RenamedDirectories[oldRelativePath] = newRelativePath; } else if (previouslyRenamedRelativePath.EqualsIgnoreCase(newRelativePath)) { changeset.RenamedDirectories.Remove(previouslyRenamedRelativePath); } else { changeset.RenamedDirectories[previouslyRenamedRelativePath] = newRelativePath; } }
public void Apply(Changeset changeset) { if (!_fullPath.StartsWithIgnoreCase(_rootDirectory)) { return; } var relativePath = PathHelper.EnsureTrailingSlash(PathHelper.MakeRelative(_rootDirectory, _fullPath)); // Remove all the files and directories that start with relativePath changeset.AddedDirectories.RemoveWhere(d => d.StartsWithIgnoreCase(relativePath)); changeset.AddedFiles.RemoveWhere(f => f.StartsWithIgnoreCase(relativePath)); // If directory was previously added to AddedDirectories, we need to remove all its content as well if (changeset.AddedDirectories.Remove(relativePath)) { return; } // If directory was renamed into relativePath, put the oldRelativePath into RemovedFiles instead. var oldRelativePath = changeset.RenamedDirectories.GetFirstKeyByValueIgnoreCase(relativePath); if (oldRelativePath != null) { changeset.RenamedDirectories.Remove(oldRelativePath); changeset.RemovedDirectories.Add(oldRelativePath); return; } changeset.RemovedDirectories.Add(relativePath); }
public TFSRevision(Repository repo, string itemPath, Changeset changeset) : this(repo, changeset.ChangesetId, itemPath) { this.Author = changeset.Committer; this.Message = changeset.Comment; this.Time = changeset.CreationDate; }
public Changeset GetParentCommit(Changeset commit) { var command = new LogCommand().WithRevision(new RevSpec("{0}^".Fmt(commit.Hash))).WithIncludePathActions(); var changesets = _repository.Log(command); var changeset = changesets.FirstOrDefault(); return changeset; }
/// <summary> /// Merges the specified changesets. /// </summary> /// <param name="changeset1">The changeset1.</param> /// <param name="changeset2">The changeset2.</param> /// <param name="source">The source.</param> /// <returns></returns> public Changeset<IChange> Merge(MergableChangeset changeset1, MergableChangeset changeset2, IReadOnlyList<string> source) { var result = new Changeset<IChange>(); IEnumerable<IChange> changes = CollectChanges(changeset1, changeset2, source); foreach (IChange change in changes) { result.Add(change.Start, change); } return result; }
public void ParseSingleChangesetSpec() { string plasticChangesetEnvironVar = "cs:19@br:/main/test2/@rep:codice@repserver:skull.mydomain.com:9095"; Changeset expectedChangeset = new Changeset( 19, "/main/test2/", "codice", "skull.mydomain.com:9095"); List <Changeset> changesets = Changeset.ParsePlasticChangesetEnvironVar(plasticChangesetEnvironVar); Assert.AreEqual(1, changesets.Count); AssertChangesetEquals(expectedChangeset, changesets[0]); }
public void changes_must_be_applied_in_strict_order() { var ticket = TicketTestFactory.ForTest(); var persister = (IEventSourcedAggregate)ticket; var first = new Changeset(1, new TicketSold()); var third = new Changeset(3, new TicketSold()); persister.ApplyChanges(first); var ex = Assert.Throws <AggregateRestoreException>(() => { persister.ApplyChanges(third); }); Assert.Equal(2, ex.ExpectedVersion); Assert.Equal(3, ex.RestoreVersion); }
static void RunAfterCheckin( List <string> filteredRepos, List <string> dstServers, List <RepoMapping> mappings, string csetSpecs, ErrorEmailSender emailSender) { Logger.LogInfo("Running as after-checkin trigger..."); List <Changeset> csets = Changeset.ParsePlasticChangesetEnvironVar(csetSpecs); List <Replica> pendingReplicas = new List <Replica>(); foreach (Changeset cset in csets) { pendingReplicas.AddRange( Replica.BuildPendingReplicas( cset.BranchName, cset.RepositoryName, cset.ServerName, filteredRepos, dstServers, mappings)); } Logger.LogInfo( $"Found {pendingReplicas.Count} destinations to replicate to."); List <Replica> failedReplicas = new List <Replica>(); foreach (Replica pendingReplica in pendingReplicas) { if (!Replicate(pendingReplica)) { failedReplicas.Add(pendingReplica); } } NotifyFailedReplicas( "after-checkin", failedReplicas, emailSender); }
private void ProcessFileChange(Changeset changeset, Change change) { // Undelete file (really just an add) if ((change.ChangeType & ChangeType.Undelete) == ChangeType.Undelete) { UndeleteFile(changeset, change); } // Rename file. else if ((change.ChangeType & ChangeType.Rename) == ChangeType.Rename) { RenameFile(changeset, change); //"Edit, Rename" is possible and should be handled if ((change.ChangeType & ChangeType.Edit) == ChangeType.Edit) { EditFile(changeset, change); } } // Branch file. else if ((change.ChangeType & ChangeType.Branch) == ChangeType.Branch) { BranchFile(changeset, change); } // Add file. else if ((change.ChangeType & ChangeType.Add) == ChangeType.Add) { AddFile(changeset, change); } // Delete file. else if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete) { DeleteFile(changeset, change); } // Edit file. else if ((change.ChangeType & ChangeType.Edit) == ChangeType.Edit) { EditFile(changeset, change); } }
/// <summary> /// Convert the passed changeset to an array of modifcations. /// </summary> private Modification[] toModifcations(Changeset changeset) { List <Modification> modifications = new List <Modification>(); string userName = changeset.Committer; string comment = changeset.Comment; int changeNumber = changeset.ChangesetId; // In VSTS, the version of the file is the same as the changeset number it was checked in with. string version = Convert.ToString(changeNumber); DateTime modifedTime = this.TFS.TimeZone.ToLocalTime(changeset.CreationDate); foreach (Change change in changeset.Changes) { Modification modification = new Modification(); modification.UserName = userName; modification.Comment = comment; modification.ChangeNumber = changeNumber; modification.ModifiedTime = modifedTime; modification.Version = version; modification.Type = PendingChange.GetLocalizedStringForChangeType(change.ChangeType); // Populate fields from change item Item item = change.Item; if (item.ItemType == ItemType.File) { // split into foldername and filename int lastSlash = item.ServerItem.LastIndexOf('/'); modification.FileName = item.ServerItem.Substring(lastSlash + 1); // patch to the following line submitted by Ralf Kretzschmar. modification.FolderName = item.ServerItem.Substring(0, lastSlash); } else { // TODO - what should filename be if dir?? Empty string or null? modification.FileName = string.Empty; modification.FolderName = item.ServerItem; } Log.Debug(modification.ToString()); modifications.Add(modification); } return(modifications.ToArray()); }
private static void SetLastWorkItem(ITeamExplorer teamExplorer, Changeset changeset) { var workItemId = GetAssociatedWorkItemId(changeset); if (workItemId == 0) { return; } var pendingChangesPage = (TeamExplorerPageBase)teamExplorer.NavigateToPage(new Guid(TeamExplorerPageIds.PendingChanges), null); var model = (IPendingCheckin)pendingChangesPage.Model; var modelType = model.GetType(); var method = modelType.GetMethod("AddWorkItemsByIdAsync", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); var workItemsIdsArray = new[] { workItemId }; method.Invoke(model, new object[] { workItemsIdsArray, 1 /* Add */ }); }
static void Main(string[] args) { string tfsurl = "http://tfscollectionurl"; TfsTeamProjectCollection ttpc = new TfsTeamProjectCollection(new Uri(tfsurl)); VersionControlServer vcs = ttpc.GetService <VersionControlServer>(); string[] path = { "$/Path/To/Item.cs" }; ItemSpec[] itemSpecs = ItemSpec.FromStrings(path, RecursionType.Full); ItemSpec itemSpec = itemSpecs.Cast <ItemSpec>().First(); IEnumerable <Changeset> changesets = vcs.QueryHistory(itemSpec); Changeset latestchangeset = changesets.Cast <Changeset>().First(); Console.WriteLine(latestchangeset.Committer); Console.WriteLine(latestchangeset.CommitterDisplayName); Console.WriteLine(latestchangeset.Owner); Console.WriteLine(latestchangeset.OwnerDisplayName); Console.WriteLine(latestchangeset.CreationDate); Console.ReadLine(); }
public void persister_should_create_changeset_only_with_new_events() { var ticket = TicketTestFactory.ForTest(); var persister = (IEventSourcedAggregate)ticket; var changeSet = new Changeset(1, new TicketSold()); persister.ApplyChanges(changeSet); ticket.Refund(); changeSet = persister.GetChangeSet(); Assert.NotNull(changeSet); Assert.False(changeSet.IsEmpty()); Assert.Equal(2, changeSet.AggregateVersion); Assert.True(1 == changeSet.Events.Length); Assert.IsType <TicketRefunded>(changeSet.Events[0]); }
protected async Task <Changeset> ProcessEvents( DomainEvent[] evts, Func <Int64, IIdentity> generateId = null) { Int64 commitId = ++_lastCommit; generateId = generateId ?? (p => new SampleAggregateId(p)); foreach (var evt in evts) { evt.SetPropertyValue(d => d.AggregateId, generateId(_aggregateIdSeed)); evt.SetPropertyValue(d => d.CheckpointToken, commitId); } Changeset cs = new Changeset(_aggregateVersion++, evts); var chunk = await _persistence.AppendAsync(evts[0].AggregateId, cs).ConfigureAwait(false); lastUsedPosition = chunk.Position; return(cs); }
/// <summary> /// Poll readmodel until the readmodel does not satisfy condition or timeout is reached. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="changeset"></param> /// <param name="conditionToAssert"></param> private void AssertForReadmodelCondition <T>(Changeset changeset, Func <T, Boolean> conditionToAssert) where T : class, IAtomicReadModel { var firstEvent = changeset.Events[0] as DomainEvent; DateTime startWait = DateTime.UtcNow; var collection = GetCollection <T>(); while (DateTime.UtcNow.Subtract(startWait).TotalSeconds < 5) { var record = collection.FindOneById(firstEvent.AggregateId.AsString()); if (record != null && conditionToAssert(record)) { return; //Assertion is correct } Thread.Sleep(100); } Assert.Fail("Condition not met in the allotted timespan"); }
private Func <IBuildDetail, bool> GetFilter() { if (UserContext != null) { return(detail => detail.RequestedFor == UserContext.UserName); } Changeset changeset = GetChangesetFromCurrentPage(); if (changeset != null) { return(detail => { var chString = detail.SourceGetVersion.Replace("C", ""); return (changeset.ChangesetId.ToString() == chString) || (InformationNodeConverters.GetAssociatedChangesets(detail).Any(summary => summary.ChangesetId == changeset.ChangesetId)); }); } return(detail => true); }
private void ProcessLogEntry(Repository repo, Changeset commit) { var logEntryDto = new LogEntryDto { Revision = commit.RevisionNumber.ToString(), Author = commit.AuthorName, CommittedDate = commit.Timestamp, Message = "("+commit.Branch + ") " + commit.CommitMessage, ChangedFiles = new List<ChangedFileDto>() }; foreach (ChangesetPathAction change in commit.PathActions) { var changeFileDto = new ChangedFileDto { FileName = change.Path, ChangeType = MercurialChangeStatusToChangeType(change.Action) }; switch (changeFileDto.ChangeType) { case ChangeType.Added: changeFileDto.OldVersion = new byte[0]; changeFileDto.NewVersion = GetFile(repo, commit.RevisionNumber, change.Path); break; case ChangeType.Deleted: changeFileDto.OldVersion = GetFile(repo, commit.LeftParentRevision, change.Path); changeFileDto.NewVersion = new byte[0]; break; default: changeFileDto.OldVersion = GetFile(repo, commit.LeftParentRevision, change.Path); changeFileDto.NewVersion = GetFile(repo, commit.RevisionNumber, change.Path); break; } logEntryDto.ChangedFiles.Add(changeFileDto); } var args = new NewLogEntryEventArgs { LogEntry = logEntryDto }; OnNewLogEntry(args); MaxDateTimeRetrieved = logEntryDto.CommittedDate; }
/// <summary> /// this function acts as a proxy for the function below it. /// </summary> public IList <QueryRec> queryMerge(Changeset cs, string targetPath, int distance) { saastdlib.Timer t = new saastdlib.Timer(); t.start(); /* pull down the item type. * i need this to determine params for the querymergedetails call. */ Item itm = _getItem(targetPath, cs.ChangesetId, 0, false); IList <QueryRec> queries = queryMerge(cs, itm, distance); t.stop(); Logger.logger.DebugFormat("qm[{0} queries took {1}]", this.QueryCount, this.QueryTime); Logger.logger.DebugFormat("qm[{0} get items took {1}]", this.GetItemCount, this.GetItemTime); Logger.logger.DebugFormat("qm[{0} get changesets took {1}]", this.GetChangesetCount, this.GetChangesetTime); Logger.logger.DebugFormat("qm[total time {1}]", t.Total); return(queries); }
public async Task Verify_basic_fix_for_readmodel() { //Arrange: Generate some commit and project them Changeset changeset = await GenerateSomeEvents().ConfigureAwait(false); var engine = await CreateSutAndStartProjectionEngineAsync().ConfigureAwait(false); GetTrackerAndWaitForChangesetToBeProjected("SimpleTestAtomicReadModel"); await engine.StopAsync().ConfigureAwait(false); //Act, start the fixer and change signature SimpleTestAtomicReadModel.FakeSignature = 2; var sut = GenerateSut(); sut.AddReadmodelToFix(typeof(SimpleTestAtomicReadModel)); sut.StartFixing(); //ok I'm expecting the fix to correct the readmodel AssertForReadmodelCondition <SimpleTestAtomicReadModel>(changeset, rm => rm.ReadModelVersion == 2 && rm.TouchCount == 4); }
public static RevisionInfo ToRevisionInfo(this Changeset changeset) { return(new RevisionInfo { Author = changeset.AuthorName, Comment = changeset.CommitMessage, Id = new RevisionId() { Time = changeset.Timestamp, Value = changeset.Hash }, Time = changeset.Timestamp, Entries = changeset.PathActions .Select(pa => new RevisionEntryInfo() { Path = pa.Path, Action = pa.Action.ToFileAction() }).ToArray(), Email = changeset.AuthorEmailAddress, TimeCreated = changeset.Timestamp }); }
/// <summary> /// Merges the specified changesets. /// </summary> /// <param name="changeset1">The changeset1.</param> /// <param name="changeset2">The changeset2.</param> /// <param name="source">The source.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException"></exception> public Changeset <IChange> Merge(MergableChangeset changeset1, MergableChangeset changeset2, IReadOnlyList <string> source) { if ((changeset1 == null) || (changeset2 == null) || (source == null)) { throw new ArgumentNullException(); } changeset1.Verify(source.Count); changeset2.Verify(source.Count); var result = new Changeset <IChange>(); foreach (int key in changeset1.Keys) { result.Add(key, changeset1[key]); } return(result); }
private List <Changeset> ExtractDifferentialChanges(TId id, IOrderedEnumerable <HistoricalEvent> events, HistoricalEvent sourceEvent, TEntity sourceObject) { var differentialChangeset = new List <Changeset>(); var currentEvent = sourceEvent; var currentObject = sourceObject; var currentDto = _mapper.Map <TDto>(currentObject); for (int i = 1; i < events.Count(); i++) { var nextEvent = events.ToArray()[i]; var nextEventObject = JsonConvert.DeserializeObject <TEntity>(currentEvent.Changeset.ObjectDelta); var nextEventDto = _mapper.Map <TDto>(nextEventObject); var changeset = new Changeset(); changeset.EventDate = currentEvent.CreatedDate.Value; changeset.UserId = currentEvent.CreatedBy; changeset.ChangesetId = currentEvent.Changeset.Id; changeset.EventName = currentEvent.Action; changeset.Changes = _historicalCrudReadService.ExtractChanges(currentDto, nextEventDto); differentialChangeset.Add(changeset); currentObject = nextEventObject; currentDto = _mapper.Map <TDto>(currentObject); currentEvent = nextEvent; } // add last event to current object var lastChangeset = new Changeset(); var lastEvent = events.Last(); lastChangeset.EventDate = lastEvent.CreatedDate.Value; lastChangeset.UserId = lastEvent.CreatedBy; lastChangeset.ChangesetId = lastEvent.Changeset.Id; lastChangeset.Changes = lastEvent.Action != HistoricalActions.Delete.ToString() ? _historicalCrudReadService.ExtractChanges( _mapper.Map <TDto>(currentObject), _mapper.Map <TDto>(_repository.GetById <TId, TEntity>(id))) : null; lastChangeset.EventName = lastEvent.Action; differentialChangeset.Add(lastChangeset); return(differentialChangeset); }
private static void FeedVersionControlData(ICollection <VersionControlItem> versionControlItemCollection, TfsTeamProjectCollection tpc, string projectName) { VersionControlServer vcs = tpc.GetService <VersionControlServer>(); ItemSet items = vcs.GetItems("$/" + projectName + "/*", RecursionType.None); foreach (Item item in items.Items) { int itemChangeSetId = item.ChangesetId; DateTime lastInnerCheckInDate = DateTime.MinValue; int lastInnerChangeSetId = 0; IEnumerable history = vcs.QueryHistory(item.ServerItem, VersionSpec.Latest, item.DeletionId, RecursionType.Full, null, new ChangesetVersionSpec(itemChangeSetId), VersionSpec.Latest, Int32.MaxValue, false, false); IEnumerator enumerator = history.GetEnumerator(); if (enumerator.MoveNext()) { Changeset lastChangeSet = enumerator.Current as Changeset; if (lastChangeSet != null) { lastInnerCheckInDate = lastChangeSet.CreationDate; lastInnerChangeSetId = lastChangeSet.ChangesetId; } } VersionControlItem vci = new VersionControlItem() { DisplayName = item.ServerItem, ItemChangeSetId = itemChangeSetId, ItemLastCheckIn = item.CheckinDate, InnerChangeSetId = lastInnerChangeSetId, InnerLastCheckIn = lastInnerCheckInDate }; versionControlItemCollection.Add(vci); } }
private void _queueOrVisit(QueryProcessor qp, Changeset cs, int distance, string branch) { Revision rev = _results.getRevision(cs.ChangesetId); if (rev == null) { /* ok, ok, we really don't have it... * didn't find it, so do the first level query. */ if (!_handleVisit(qp, cs, distance)) { /* manufacture a visit since this changeset * has no merge actions to get branches from */ if (branch == null) { /* determine a branch from the changesets's changes * we're not queuing it, so we look for _all_ branches. * (eg, 2nd level :[ ) */ List <string> branches = tfsinterface.Utils.FindChangesetBranches(cs, (cng) => true); foreach (string b in branches) { _results.construct(b, cs); } } else { Logger.logger.DebugFormat("building {0}", cs.ChangesetId); _results.construct(branch, cs); } } } else { /* woo, got nothing left to do! */ } }
protected virtual bool HasWorkItems(Changeset changeset) { // This method wraps changeset.WorkItems, because // changeset.WorkItems might result to ConnectionException: TF26175: Team Foundation Core Services attribute 'AttachmentServerUrl' not found. // in this case assume that it is initialized to null // NB: in VS2011 a new property appeared (AssociatedWorkItems), which works correctly WorkItem[] result = null; try { result = changeset.WorkItems; } catch (ConnectionException exception) { if (!exception.Message.StartsWith("TF26175:")) { throw; } } return(result != null && result.Length > 0); }
private ITfsChangeset BuildTfsChangeset(Changeset changeset, GitTfsRemote remote) { var tfsChangeset = _container.With <ITfsHelper>(this).With <IChangeset>(_bridge.Wrap <WrapperForChangeset, Changeset>(changeset)).GetInstance <TfsChangeset>(); tfsChangeset.Summary = new TfsChangesetInfo { ChangesetId = changeset.ChangesetId, Remote = remote }; if (changeset.WorkItems != null) { tfsChangeset.Summary.Workitems = changeset.WorkItems.Select(wi => new TfsWorkitem { Id = wi.Id, Title = wi.Title, Description = wi.Description, Url = Linking.GetArtifactUrl(wi.Uri.AbsoluteUri) }); } return(tfsChangeset); }
/// <summary> /// is the changeset passed in a merge changeset? /// it looks at the changes contained in the changeset to make that determiniation /// </summary> /// <param name="cs"></param> /// <returns></returns> public static bool IsMergeChangeset(Changeset cs) { bool isMerge = false; int changesCount = cs.Changes.Length; for (int i = 0; i < changesCount; ++i) { Change cng = cs.Changes[i]; isMerge = ((cng.ChangeType & ChangeType.Branch) == ChangeType.Branch || (cng.ChangeType & ChangeType.Merge) == ChangeType.Merge); if (isMerge) { break; } } return(isMerge); }
/// <summary> /// Helper method that request the agrsso code with a given changeset id /// </summary> /// <param name="changesetId"></param> /// <returns></returns> public async Task <string> GetAgressoCode(int?changesetId) { if (!changesetId.HasValue) { return(string.Empty); } string cacheKey = string.Format("GetAgressoCode{0}", changesetId.Value); return(await _cacheManager.Resolve(cacheKey, async() => { Changeset changeset = await _changesets.GetChangeset(changesetId.ToString()); if (changeset?.WitList != null && changeset.WitList.Count > 0) { WorkItem wit = await _wit.GetWorkItem(changeset.WitList?.First()?.Id.ToString()); string codeProject = wit?.WitFields?.ProjectCodeAgresso ?? wit?.WitFields?.MantisProject; return codeProject; } return "no project name"; })); }
public static void InsertData(Changeset Changeset, MySqlConnection myConnection) { try { string query = "INSERT IGNORE INTO changeset (ChangesetId, Comment, CreatedDate, DevelopperId)"; query += " VALUES (@ChangesetId, @Comment, @CreatedDate, @DevelopperId)"; MySqlCommand myCommand = new MySqlCommand(query, myConnection); myCommand.Parameters.AddWithValue("@ChangesetId", Changeset.ChangesetId); myCommand.Parameters.AddWithValue("@Comment", Changeset.Comment); myCommand.Parameters.AddWithValue("@CreatedDate", Changeset.CreatedDate); myCommand.Parameters.AddWithValue("@DevelopperId", Changeset.DevelopperId); int row = myCommand.ExecuteNonQuery(); } catch (Exception e) { string error = "Exception Occre while Inserting in table changeset:" + e.Message + "\t" + e.GetType(); } }
public Changeset ExtractOneDifferentialChangeset <T2>(HistoricalEvent currentEvent, HistoricalEvent nextEvent) where T2 : class, IEntity <T1>, new() { var currentObject = JsonConvert.DeserializeObject <T2>(currentEvent.Changeset.ObjectDelta); var nextObject = nextEvent.Action == HistoricalActions.Delete.ToString() ? JsonConvert.DeserializeObject <T2>(nextEvent.Changeset?.ObjectData) : JsonConvert.DeserializeObject <T2>(nextEvent.Changeset?.ObjectDelta); var changeset = new Changeset(); changeset.EventDate = nextEvent.CreatedDate.Value; changeset.UserId = nextEvent.CreatedBy; changeset.ChangesetId = nextEvent.Changeset.Id; changeset.EventName = nextEvent.Action; changeset.Changes = currentEvent.Action != HistoricalActions.Delete.ToString() ? ExtractChanges(currentObject, nextObject) : null; return(changeset); }
static void GetVersionByChangeset(Uri tfsUri, string serverPath, int changesetId) { TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(tfsUri); VersionControlServer vcs = tpc.GetService <VersionControlServer>(); Changeset changeset = vcs.GetChangeset(changesetId); WorkingFolder workfolder = new WorkingFolder(serverPath, @"C:\tsf_" + changesetId); Workspace workspace = vcs.CreateWorkspace(changesetId.ToString()); workspace.CreateMapping(workfolder); GetStatus status = workspace.Get(VersionSpec.ParseSingleSpec( String.Format("C{0}", changesetId), null) , GetOptions.GetAll); workspace.Delete(); StreamWriter fileWriter = new StreamWriter(@"C:\tsf_" + changesetId + @"\Database_snapshot.txt", false); fileWriter.WriteLine(changeset.Comment); fileWriter.Close(); fileWriter.Dispose(); }
public void Apply(Changeset changeset) { string relativePath; if (!IsFileAllowed(_rootDirectory, _fullPath, _fileSystem, _fileSystemFilter, out relativePath)) { return; } // If file with the same name was removed, just remove it from the RemovedFiles set if (changeset.RemovedFiles.Remove(relativePath)) { return; } // If file had this name before renaming, remove it from RenamedFiles and add to AddedFiles instead string renamedFile; if (changeset.RenamedFiles.TryGetValue(relativePath, out renamedFile)) { changeset.RenamedFiles.Remove(relativePath); changeset.AddedFiles.Add(renamedFile); return; } changeset.AddedFiles.Add(relativePath); }
static void Main(string[] args) { string projecturi = "https://xxx:8080/tfs/"; int changesetid = xxx; TfsTeamProjectCollection ttpc = new TfsTeamProjectCollection(new Uri(projecturi)); VersionControlServer vcs = ttpc.GetService <VersionControlServer>(); Changeset cset = vcs.GetChangeset(changesetid); TeamFoundationDiscussionService tfds = new TeamFoundationDiscussionService(); tfds.Initialize(ttpc); IDiscussionManager idm = tfds.CreateDiscussionManager(); IAsyncResult iar = idm.BeginQueryByVersion(cset.ArtifactUri, QueryStoreOptions.ServerOnly, new AsyncCallback(Callback), null); var threads = idm.EndQueryByVersion(iar); foreach (DiscussionThread dt in threads) { Console.WriteLine(dt.RootComment.Content); Console.WriteLine(dt.RootComment.Author.DisplayName); Console.ReadLine(); } }
/** * @param srcPath item path * @param srcVersion version * @param maxChanges maximum number of changes to query for. */ public virtual bool visit(string srcPath, VersionSpec srcVersion, int maxChanges) { bool result = true; _tree = megahistory.SCMUtils.GetBranches(_vcs, srcPath, srcVersion); System.Collections.IEnumerable foo = _vcs.QueryHistory(srcPath, srcVersion, 0, RecursionType.Full, null, null, null, /* user, from ver, to ver */ maxChanges, true, false, false); /* inc changes, slot mode, inc download info. */ foreach (object o in foo) { Changeset cs = o as Changeset; bool isMerge = false; result &= true; isMerge = megahistorylib.Utils.IsMergeChangeset(cs); if (isMerge) { visit(0, srcPath, cs.ChangesetId); } else { _visitor.visit(0, cs); } _visitor.reset(); } /* dump some stats out to the log file. */ MH.logger.DebugFormat("{0} queries took {1}", _queries, _queryTimer.Total); MH.logger.DebugFormat("{0} findchangesetbranchcalls for {1} changesets.", megahistorylib.Utils.FindChangesetBranchesCalls, _visitor.visitedCount()); return(result); }
public void Apply(Changeset changeset) { if (!_fullPath.StartsWithIgnoreCase(_rootDirectory)) { return; } var relativePath = PathHelper.MakeRelative(_rootDirectory, _fullPath); // If the file with the same name was previously added, just remove it from the AddedFiles set if (changeset.AddedFiles.Remove(relativePath)) { return; } // if the file was renamed into relativePath, put the oldRelativePath into RemovedFiles instead. var oldRelativePath = changeset.RenamedFiles.GetFirstKeyByValueIgnoreCase(relativePath); if (oldRelativePath != null) { changeset.RenamedFiles.Remove(oldRelativePath); changeset.RemovedFiles.Add(oldRelativePath); return; } changeset.RemovedFiles.Add(relativePath); }
public static void Tag(Changeset changeset, Change change, string fileName) { var sr = new StreamReader(fileName); var tempFile = sr.ReadToEnd(); sr.Close(); var sw = new StreamWriter(fileName); sw.WriteLine("----------------------------------------------------"); sw.WriteLine("-- ChangesetId: {0}{1}-- ServerItem: {2}", changeset.ChangesetId, Environment.NewLine, change.Item.ServerItem); sw.WriteLine("-- Changeset Creation Date: {0}, Owner: {1}, Committer: {2}", changeset.CreationDate, changeset.Owner, changeset.Committer); foreach (var workItem in changeset.WorkItems) { sw.WriteLine("-- WorkItem: " + workItem.Id); } sw.WriteLine("----------------------------------------------------" + Environment.NewLine); sw.Write(tempFile); sw.Close(); }
/// <summary> /// Returns the changeset type. /// </summary> private ChangesetType GetChangeType(Changeset chg) { if (chg.RevertedChangesetId != null) { return(ChangesetType.Restored); } var wasNull = string.IsNullOrEmpty(chg.OriginalState); var isNull = string.IsNullOrEmpty(chg.UpdatedState); if (wasNull) { return(ChangesetType.Created); } if (isNull) { return(ChangesetType.Removed); } return(ChangesetType.Updated); }
public static Changeset[] GetUsersChangesets(long userId) { var changes = new List <Changeset>(); var oneDay = TimeSpan.FromDays(1); var newChanges = new Changeset[0]; do { var before = newChanges.DefaultIfEmpty(new Changeset() { CreatedAt = DateTime.UtcNow }).Min(c => c.CreatedAt.Value); newChanges = OsmApiClient.QueryChangesets(null, userId, null, DateTime.MinValue, null, false, false, null).Result; Thread.Sleep(10000); if (newChanges != null) { changes.AddRange(newChanges); } } while (newChanges?.Length == 100); return(changes.ToArray()); }
public void Apply(Changeset changeset) { string newRelativePath; if (!IsFileAllowed(_rootDirectory, _fullPath, _fileSystem, _fileSystemFilter, out newRelativePath)) { return; } var oldRelativePath = PathHelper.MakeRelative(_rootDirectory, _oldFullPath); var isRename = true; // If file with the oldRelativePath was previously added, remove it from the AddedFiles and add newRelativePath if (changeset.AddedFiles.Remove(oldRelativePath)) { changeset.AddedFiles.Add(newRelativePath); isRename = false; } // if file with the newRelativePath was previously deleted, remove it from the RemovedFiles and add oldRelativePath if (changeset.RemovedFiles.Remove(newRelativePath)) { changeset.RemovedFiles.Add(oldRelativePath); isRename = false; } if (!isRename) { return; } // if there is a file that was renamed into oldRelativePath, rename it to newRelativePath instead // or remove from RenamedFiles if previouslyRenamedRelativePath equal to newRelativePath var previouslyRenamedRelativePath = changeset.RenamedFiles.GetFirstKeyByValueIgnoreCase(oldRelativePath); if (string.IsNullOrEmpty(previouslyRenamedRelativePath)) { changeset.RenamedFiles[oldRelativePath] = newRelativePath; } else if (previouslyRenamedRelativePath.EqualsIgnoreCase(newRelativePath)) { changeset.RenamedFiles.Remove(previouslyRenamedRelativePath); } else { changeset.RenamedFiles[previouslyRenamedRelativePath] = newRelativePath; } }
private string GetTextFileContentSafe(Changeset commit, string path) { try { return GetFileContent(commit, path); } catch { return string.Empty; } }
private string GetFileContent(Changeset commit, string path) { return _mercurial.GetFileContent(commit, path); }
private DiffResult GetDiff(string path, Changeset prevCommmit, Changeset commit) { var fileContent = GetTextFileContentSafe(commit, path); var previousRevisionFileContent = GetTextFileContentSafe(prevCommmit, path); var diff = _diffProcessor.GetDiff(previousRevisionFileContent, fileContent); diff.LeftPanRevisionId = prevCommmit.RevisionNumber.ToString(); diff.RightPanRevisionId = commit.RevisionNumber.ToString(); return diff; }
private void UndeleteFolder(Changeset changeset, Change change) { string itemPath = GetItemPath(change.Item); Directory.CreateDirectory(itemPath); if (this.FolderUndeleted != null) this.FolderUndeleted(changeset.ChangesetId, itemPath, changeset.Committer, changeset.Comment, changeset.CreationDate); }
public string GetFileContent(Changeset commit, string path) { var command = new CatCommand().WithFile(path); if (commit != null) { command = command.WithAdditionalArgument(string.Format("-r {0}", commit.RevisionNumber)); } _repository.Execute(command); return command.RawStandardOutput; }
public void Apply(Changeset changeset) { }
public Changeset GetParentCommit(Changeset commit) { var command = new LogCommand().WithIncludePathActions(); var changeset = _repository.Log(command) .FirstOrDefault(ch => ch.RevisionNumber == (commit.RevisionNumber > 0 ? commit.RevisionNumber - 1 : commit.RevisionNumber)); return changeset; }
public static Changeset CreateChangeset(int ID, global::System.DateTime creationDate) { Changeset changeset = new Changeset(); changeset.Id = ID; changeset.CreationDate = creationDate; return changeset; }
/// <summary> /// Parse the given XML lazily and return a collection of <see cref="Changeset"/> /// objects for the information contained in it, in the order the changesets /// appear in the xml. /// </summary> /// <param name="xml"> /// The XML to parse. /// </param> /// <returns> /// A collection of <see cref="Changeset"/> objects. /// </returns> /// <exception cref="InvalidOperationException"> /// <para>An unknown path action character was detected in the log output.</para> /// <para>- or -</para> /// <para>The XML content was not legal according to the expected format.</para> /// </exception> public static IEnumerable<Changeset> LazyParse(string xml) { if (StringEx.IsNullOrWhiteSpace(xml)) yield break; var serializer = new XmlSerializer(typeof(LogEntryNode)); foreach (string entryXml in LazyExtractChangesetXmlPieces(xml)) { var entry = (LogEntryNode)serializer.Deserialize(new StringReader(entryXml)); var changeset = new Changeset { Timestamp = entry.Timestamp, AuthorName = (entry.Author ?? new LogEntryAuthorNode()).Name, AuthorEmailAddress = (entry.Author ?? new LogEntryAuthorNode()).Email, CommitMessage = entry.CommitMessage ?? string.Empty, Branch = entry.Branch ?? "default", Hash = entry.Hash, RevisionNumber = entry.Revision, Revision = RevSpec.Single(entry.Hash), Tags = entry.Tags.Select(t => t.Name).ToArray(), }; switch (entry.Parents.Count) { case 2: changeset.RightParentHash = entry.Parents[1].Hash; changeset.RightParentRevision = entry.Parents[1].Revision; goto case 1; case 1: changeset.LeftParentHash = entry.Parents[0].Hash; changeset.LeftParentRevision = entry.Parents[0].Revision; break; case 0: changeset.LeftParentRevision = changeset.RevisionNumber - 1; break; } foreach (LogEntryPathNode action in entry.PathActions) { var pathAction = new ChangesetPathAction { Path = action.Path, }; switch (action.Action) { case "M": pathAction.Action = ChangesetPathActionType.Modify; break; case "A": pathAction.Action = ChangesetPathActionType.Add; LogEntryCopyNode copySource = entry.Copies.Where(c => c.Destination == action.Path).FirstOrDefault(); if (copySource != null) pathAction.Source = copySource.Source; break; case "R": pathAction.Action = ChangesetPathActionType.Remove; break; default: throw new InvalidOperationException("Unknown path action: " + action.Action); } changeset.PathActions.Add(pathAction); } yield return changeset; } }
/// <summary> /// Updates the issue tracker from the change set. /// </summary> /// <param name="repository"> </param> /// <param name="changeset"> </param> /// <param name="service"> </param> public static void UpdateBugNetForChangeset(string repository, Changeset changeset, WebServices.BugNetServices service) { var issuesAffectedList = new List<int>(); var regEx = new Regex(AppSettings.IssueIdRegEx, RegexOptions.IgnoreCase); var commitMessage = changeset.CommitMessage.Trim(); var matchResults = regEx.Match(commitMessage); if (!matchResults.Success) // none in the commit message { Log.Info("MercurialChangeGroupHook: Found no Issue Ids in change set"); return; } // capture the issues ids in the commit message // validate if the issue id is // change the commit message for each issue id (may be more to the commit) while (matchResults.Success) { var value = matchResults.Groups[1].Value.Trim(); var issueIdParts = value.Split(new[] { '-' }); if (issueIdParts.Length.Equals(2)) { var idString = issueIdParts[1]; int issueId; if (int.TryParse(idString, out issueId)) { if(service.ValidIssue(issueId)) // check the issue to make sure it exists { commitMessage = Regex.Replace(commitMessage, AppSettings.IssueIdRegEx, "<a href=\"IssueDetail.aspx?id=$2#top\"><b>$1</b></a>"); issuesAffectedList.Add(issueId); } } } matchResults = matchResults.NextMatch(); } if (issuesAffectedList.Count <= 0) return; var revisionNumber = changeset.RevisionNumber; var revision = changeset.Hash.Trim(); var author = changeset.AuthorName.Trim(); var dateTime = changeset.Timestamp.ToString(); var branch = changeset.Branch.Trim(); foreach (var id in issuesAffectedList) { try { Log.Info("MercurialChangeGroupHook: Creating new issue revision"); var success = service.CreateNewIssueRevision( revisionNumber, id, repository, author, dateTime, commitMessage, revision, branch); if (success) Log.Info("MercurialChangeGroupHook: Successfully added new issue revision"); else Log.Warn("MercurialChangeGroupHook: Adding new issue revision failed"); } catch (Exception ex) { Log.ErrorFormat("MercurialChangeGroupHook: An error occurred adding a new issue revision to BugNET: {0} \n\n {1}", ex.Message, ex.StackTrace); } } }
private void Consume(Changeset changeset) { IFileSystemChange change; while (_queue.TryDequeue(out change)) { try { _log.WatcherApplyChange(change.ToString()); change.Apply(changeset); } catch (Exception e) { _log.WatcherApplyChangeFailed(change.ToString(), e); Debug.Fail($"Failed to apply change {change}:\n{e}"); throw; } } }
private ChangeSet CreateChangeSet(Changeset changeSet) { return new ChangeSet(changeSet.Hash, changeSet.AuthorName, changeSet.AuthorEmailAddress, changeSet.CommitMessage, new DateTimeOffset(changeSet.Timestamp)); }
private void ParseBatchContent(Stream contentStream, string contentType, bool isResponse, bool matchToExisting) { int partIndex = 0; int changesetIndex = 0; if (!matchToExisting) { this.changesets = new List<Changeset>(); this.parts = new List<InMemoryWebRequest>(); } MemoryStream memoryStream = new MemoryStream(); // Create a copy since StreamReader will Close the stream, which might not be what we want TestUtil.CopyStream(contentStream, memoryStream); memoryStream.Position = 0; using (TextReader reader = new StreamReader(memoryStream)) { Assert.IsTrue(contentType.StartsWith("multipart/mixed; "), "Response is not a batch response. Expecting 'multipart.mixed', got '" + contentType + "'."); string boundary = "--" + contentType.Substring(contentType.IndexOf("; boundary=") + 11).Trim(); string endboundary = boundary + "--"; string line; while ((line = reader.ReadLine()) != null) { if (line == boundary) break; if (line == endboundary) { Assert.IsTrue(partIndex == this.parts.Count, "The response didn't contain enough parts."); return; } } while (true) { line = reader.ReadLine(); // Content-Type Assert.IsTrue(line.StartsWith("Content-Type:"), "The batch part doesn't specify its content type."); contentType = line.Substring("Content-Type:".Length).Trim(); if (contentType.StartsWith("multipart/mixed; ")) { string changesetBoundary = "--" + contentType.Substring(contentType.IndexOf("; boundary=") + 11).Trim(); string changesetEndBoundary = changesetBoundary + "--"; int cpartIndex = 0; Changeset changeset; if (matchToExisting) { Assert.IsTrue(this.changesets.Count > changesetIndex, "The batch response contains more changesets than the number of changesets sent."); changeset = this.changesets[changesetIndex]; } else { changeset = new Changeset(); this.changesets.Add(changeset); } changesetIndex++; while ((line = reader.ReadLine()) != null) { if (line.Trim().Length == 0) break; } while ((line = reader.ReadLine()) != null) { if (line == changesetBoundary) break; if (line == changesetEndBoundary) { goto ChangesetEnd; } } while (true) { reader.ReadLine(); // Content-Type reader.ReadLine(); // Content-Transfer-Encoding InMemoryWebRequest part; if (matchToExisting) { Assert.IsTrue(changeset.Parts.Count > cpartIndex, "The batch response contains more parts than the number of request parts sent."); part = changeset.Parts[cpartIndex]; } else { part = new InMemoryWebRequest(); changeset.Parts.Add(part); } line = reader.ReadLine(); if (!string.IsNullOrEmpty(line)) { part.RequestHeaders["Content-ID"] = line.Split(' ')[1]; reader.ReadLine(); } cpartIndex++; if (ParseBatchPart(isResponse, reader, part, changesetBoundary, changesetEndBoundary)) { break; } } ChangesetEnd: if (cpartIndex < changeset.Parts.Count) { int lastStatusCode = changeset.Parts[cpartIndex - 1].ResponseStatusCode; if (!UnitTestsUtil.IsSuccessStatusCode(lastStatusCode)) { for (; cpartIndex < changeset.Parts.Count; cpartIndex++) { changeset.Parts[cpartIndex].SetResponseStatusCode(lastStatusCode); } } } Assert.IsTrue(cpartIndex == changeset.Parts.Count, "The response didn't contain enough parts."); ; while (true) { line = reader.ReadLine(); if (line == boundary) break; // We can hit another exception after the changeset. For example if the changeset fails // and after the server serializes out the error for the changeset, writes the endboundary // for the changeset, and call IUpdatable.ClearChanges(), ClearChanges() can throw. // When that happens we will see the second error but there won't be any boundary after it. // We need to goto End when we either see the end boundary or reached the end of stream. if (line == null || line == endboundary) { goto End; } } } else { Assert.IsTrue(contentType.StartsWith("application/http"), "Batch part is neither changeset nor HTTP."); reader.ReadLine(); // Content-Transfer-Encoding reader.ReadLine(); // InMemoryWebRequest part; if (matchToExisting) { Assert.IsTrue(this.parts.Count > partIndex, "The batch response contains more parts than the number of request parts sent."); part = this.parts[partIndex]; partIndex++; } else { part = new InMemoryWebRequest(); this.parts.Add(part); partIndex++; } if (ParseBatchPart(isResponse, reader, part, boundary, endboundary)) { goto End; } } } End: Assert.IsTrue(partIndex == this.parts.Count, "The response didn't contain enough parts."); Assert.IsTrue(changesetIndex == this.changesets.Count, "The response didn't contain enough parts."); } }
private async Task ConsumeWaitPublish() { _log.WatcherConsumeChangesStarted(); try { var changeset = new Changeset(); while (!_queue.IsEmpty) { Consume(changeset); await Task.Delay(_delayMilliseconds); } if (!changeset.IsEmpty()) { _broadcastBlock.Post(changeset); _log.WatcherChangesetSent(changeset); } } finally { _consumerIsWorking = 0; _log.WatcherConsumeChangesFinished(); if (!_queue.IsEmpty) { StartConsumer(); } } }
public void AddToChangesets(Changeset changeset) { base.AddObject("Changesets", changeset); }
private void UndeleteFile(Changeset changeset, Change change) { string itemPath = GetItemPath(change.Item); DownloadItemFile(change, itemPath); if (this.FileUndeleted != null) this.FileUndeleted(changeset.ChangesetId, itemPath, changeset.Committer, changeset.Comment, changeset.CreationDate); }
private void RenameFolder(Changeset changeset, Change change) { string oldPath = GetItemPath(GetPreviousItem(change.Item)); string newPath = GetItemPath(change.Item); if (this.FolderRenamed != null) this.FolderRenamed(changeset.ChangesetId, oldPath, newPath, changeset.Committer, changeset.Comment, changeset.CreationDate); }
/// <summary> /// Initializes a new instance of the <see cref="Result"/> struct. /// </summary> /// <param name="changeset">The changeset.</param> /// <param name="text">The text.</param> internal Result(Changeset<IChange> changeset, IEnumerable<string> text) { Changeset = changeset; Text = text; }
private void ProcessFolderChange(Changeset changeset, Change change) { // Undelete folder. if ((change.ChangeType & ChangeType.Undelete) == ChangeType.Undelete) UndeleteFolder(changeset, change); // Rename folder. else if ((change.ChangeType & ChangeType.Rename) == ChangeType.Rename) RenameFolder(changeset, change); // Branch folder. else if ((change.ChangeType & ChangeType.Branch) == ChangeType.Branch) BranchFolder(changeset, change); // Add folder. else if ((change.ChangeType & ChangeType.Add) == ChangeType.Add) AddFolder(changeset, change); // Delete folder. else if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete) DeleteFolder(changeset, change); }
/// <summary> /// Retrieves the latest changeset ID associated with a path /// </summary> /// <param name="localPath">A path on the local filesystem</param> /// <param name="credentials">Credentials used to authenticate against the serer</param> /// <returns></returns> public int GetLatestChangesetId(string localPath, ICredentials credentials) { int latestChangesetId = 0; string server; Workstation workstation = new Workstation(versionControlClientAssembly); WorkspaceInfo workspaceInfo = workstation.GetLocalWorkspaceInfo(localPath); server = workspaceInfo.ServerUri.ToString(); VersionControlServer sourceControl = new VersionControlServer(clientAssembly, versionControlClientAssembly, server, credentials); Workspace workspace = sourceControl.GetWorkspace(localPath); WorkspaceVersionSpec workspaceVersionSpec = new WorkspaceVersionSpec(versionControlClientAssembly, workspace); VersionSpec versionSpec = new VersionSpec(versionControlClientAssembly); RecursionType recursionType = new RecursionType(versionControlClientAssembly); IEnumerable history = sourceControl.QueryHistory(localPath, versionSpec.Latest, recursionType.Full, workspaceVersionSpec); IEnumerator historyEnumerator = history.GetEnumerator(); Changeset latestChangeset = new Changeset(versionControlClientAssembly); if (historyEnumerator.MoveNext()) { latestChangeset = new Changeset(versionControlClientAssembly, historyEnumerator.Current); } if (latestChangeset.Instance != null) { latestChangesetId = latestChangeset.ChangesetId; } return latestChangesetId; }