/// <summary> /// Constructs an instance. /// </summary> /// <param name="mode"></param> /// <param name="trackProgress"></param> /// <param name="cancellationToken"></param> internal TrackProgressParameters(TrackProgressMode mode, ITrackProgress trackProgress, CancellationToken cancellationToken) { if (trackProgress == null) { throw new ArgumentNullException("trackProgress"); } TrackProgressMode = mode; TrackProgress = trackProgress; CancellationToken = cancellationToken; }
internal WaitForBackgroundActionDialog(ITrackProgress progressTracker, CancellationTokenSource cancelToken, Task task) { InitializeComponent(); ProgressTracker = progressTracker; CancelToken = cancelToken; Task = task; Timer = new DispatcherTimer(DispatcherPriority.Render); Timer.Interval = TimeSpan.FromMilliseconds(50); Timer.Tick += TimerTick; Timer.Start(); this.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen; }
/// <summary> /// Removes a progress reporter from the collection of reporters /// that are being tracked. /// </summary> /// <param name="reporterToRemove">The reporter.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="reporterToRemove"/> is <see langword="null" />. /// </exception> public void RemoveReporter(ITrackProgress reporterToRemove) { { Lokad.Enforce.Argument(() => reporterToRemove); } lock (m_Lock) { if (!m_ReporterToProgressMap.ContainsKey(reporterToRemove)) { return; } reporterToRemove.OnProgress -= ProcessNewProgress; m_ReporterToProgressMap.Remove(reporterToRemove); } }
/// <summary> /// Adds a progress reporter to the collection of reporters that /// are being tracked. /// </summary> /// <param name="reporterToAdd">The reporter.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="reporterToAdd"/> is <see langword="null" />. /// </exception> public void AddReporter(ITrackProgress reporterToAdd) { { Lokad.Enforce.Argument(() => reporterToAdd); } lock (m_Lock) { if (m_ReporterToProgressMap.ContainsKey(reporterToAdd)) { return; } reporterToAdd.OnStartProgress += ProcessStartProgress; reporterToAdd.OnProgress += ProcessNewProgress; reporterToAdd.OnStopProgress += ProcessStopProgress; m_ReporterToProgressMap.Add(reporterToAdd, new Tuple <int, string, bool>(-1, string.Empty, false)); } }
/// <summary> /// Adds a progress reporter to the collection of reporters that /// are being tracked. /// </summary> /// <param name="reporterToAdd">The reporter.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="reporterToAdd"/> is <see langword="null" />. /// </exception> public void AddReporter(ITrackProgress reporterToAdd) { { Lokad.Enforce.Argument(() => reporterToAdd); } lock (m_Lock) { if (m_ReporterToProgressMap.ContainsKey(reporterToAdd)) { return; } reporterToAdd.OnStartProgress += ProcessStartProgress; reporterToAdd.OnProgress += ProcessNewProgress; reporterToAdd.OnStopProgress += ProcessStopProgress; m_ReporterToProgressMap.Add(reporterToAdd, new Tuple<int, string, bool>(-1, string.Empty, false)); } }
public TrackProgressWithoutIncrementsWrapper(ITrackProgress wrapped) { Wrapped = wrapped; }
public IEnumerable <TfsChangesetWrapper> QueryChangesets(IEnumerable <TfsWorkItemWrapper> workItems, ITrackProgress trackProgress, CancellationToken cancelled = default(CancellationToken)) { var results = new System.Collections.Concurrent.ConcurrentBag <TfsChangesetWrapper>(); Parallel.ForEach(workItems, (workItem, state) => { if (Repository.Instance.TfsConnectionInfo.Uri == null) { state.Stop(); return; } if (cancelled.IsCancellationRequested) { state.Stop(); return; } trackProgress.Increment(); foreach (var changeset in workItem.RelatedChangesets) { trackProgress.ProgressInfo = String.Format("Processing work item #{0} ({1} related changesets)", workItem.TfsWorkItem.Id, workItem.RelatedChangesetCount); results.Add(UpdateChangesetFromCache(new TfsChangesetWrapper(changeset))); } }); cancelled.ThrowIfCancellationRequested(); var resultList = results .GroupBy(item => item.TfsChangeset.Changeset.ChangesetId) .Select(item => item.First()); return(resultList.ToList().AsEnumerable()); }
public IEnumerable <TfsWorkItemWrapper> QueryWorkItems(IEnumerable <TfsChangesetWrapper> changesets, ITrackProgress trackProgress, CancellationToken cancelled = default(CancellationToken)) { var results = new System.Collections.Concurrent.ConcurrentBag <TfsWorkItemWrapper>(); Parallel.ForEach(changesets, (changeset, state) => { if (Repository.Instance.TfsConnectionInfo.Uri == null) { state.Stop(); return; } if (cancelled.IsCancellationRequested) { state.Stop(); return; } foreach (var workItem in changeset.TfsChangeset.RelatedWorkItems) { results.Add(UpdateWorkItemFromCache(new TfsWorkItemWrapper(workItem))); } trackProgress.Increment(); }); cancelled.ThrowIfCancellationRequested(); var resultList = results .GroupBy(item => item.TfsWorkItem.Id) .Select(item => item.First()); return(resultList.ToList().AsEnumerable()); }
public bool Merge(ITfsBranch targetBranch, string pathFilter, IEnumerable <ITfsChangeset> changesetsAsEnumerable, ITrackProgress trackProgress = null) { SimpleLogger.Checkpoint("Merge: {0}, {1}", targetBranch != null ? targetBranch.Name : null, pathFilter); if (pathFilter != null && !SourceBranch.Name.StartsWith(pathFilter, StringComparison.InvariantCultureIgnoreCase)) { throw new ArgumentException("If a PathFilter is provided, it needs to be below the SourceBranch"); } var changesets = new List <ITfsChangeset>(changesetsAsEnumerable); var files = new List <string>(); if (trackProgress != null) { trackProgress.MaxProgress = changesets.Count * 2 + 2; trackProgress.CurrentProgress = 0; trackProgress.ProgressInfo = "Acquiring file list ..."; } foreach (var changeset in changesets) { SimpleLogger.Checkpoint("Merge: Processing changeset #{0}", changeset != null ? changeset.Changeset.ChangesetId : -1); foreach (var change in changeset.Changes.Select(c => c.Change)) { SimpleLogger.Checkpoint("Merge: change {0}, filter {1}", change.Item.ServerItem, pathFilter); if (pathFilter != null && change.Item.ServerItem.StartsWith(pathFilter, StringComparison.InvariantCultureIgnoreCase) == false) { continue; } files.Add(change.Item.ServerItem); } ++trackProgress.CurrentProgress; } GetRequest[] getRequests = files.Distinct().Select(file => new GetRequest(file, RecursionType.None, VersionSpec.Latest)).ToArray(); if (trackProgress != null) { trackProgress.ProgressInfo = "Getting files ..."; ++trackProgress.CurrentProgress; } SimpleLogger.Checkpoint("Merge: Getting files"); GetStatus gs = TfsWorkspace.Get(getRequests, GetOptions.None); if (trackProgress != null) { trackProgress.ProgressInfo = "Performing merges ..."; ++trackProgress.CurrentProgress; } var resultingConflicts = new List <ITfsMergeConflict>(); foreach (var changeset in changesets) { if (trackProgress != null) { ++trackProgress.CurrentProgress; } var csvs = new ChangesetVersionSpec(changeset.Changeset.ChangesetId); SimpleLogger.Checkpoint("Merge: Performing merge on CS# {0}", changeset != null ? changeset.Changeset.ChangesetId : -1); var mergeResult = TfsWorkspace.Merge( pathFilter ?? SourceBranch.Name, targetBranch.Name, csvs, csvs, LockLevel.None, RecursionType.Full, MergeOptions.ForceMerge); if (mergeResult.NumFailures > 0) { foreach (var failure in mergeResult.GetFailures()) { if (failure.Code == "TF14078" || failure.Message.Contains("TF14078")) { throw new LocalPathTooLongException(failure.Message); } throw new InvalidOperationException(failure.Message); } } } if (trackProgress != null) { trackProgress.CurrentProgress = trackProgress.MaxProgress; } SimpleLogger.Checkpoint("Merge: Refreshing conflicts"); RefreshConflictsWorker(default(CancellationToken)); SimpleLogger.Checkpoint("Merge: Finished"); return(Conflicts.Count != 0); }