Пример #1
0
        /// <summary>Deletes all stale tracking branches.</summary>
        public void Prune()
        {
            Verify.State.IsNotDeleted(this);

            var state1 = RefsState.Capture(Repository, ReferenceType.RemoteBranch);

            using (Repository.Monitor.BlockNotifications(
                       RepositoryNotifications.BranchChanged))
            {
                var parameters = GetPruneParameters();
                Repository.Accessor.PruneRemote.Invoke(parameters);
            }
            Repository.Refs.Remotes.Refresh();
            var state2  = RefsState.Capture(Repository, ReferenceType.RemoteBranch);
            var changes = RefsDiff.Calculate(state1, state2);

            Repository.Remotes.OnPruneCompleted(this, changes);
        }
Пример #2
0
        /// <summary>Deletes all stale tracking branches.</summary>
        public Task PruneAsync(IProgress <OperationProgress> progress, CancellationToken cancellationToken)
        {
            Verify.State.IsNotDeleted(this);

            progress?.Report(new OperationProgress(Resources.StrsSearchingStaleBranches.AddEllipsis()));
            var state1     = RefsState.Capture(Repository, ReferenceType.RemoteBranch);
            var block      = Repository.Monitor.BlockNotifications(RepositoryNotifications.BranchChanged);
            var parameters = GetPruneParameters();

            return(Repository.Accessor.PruneRemote.InvokeAsync(parameters, progress, cancellationToken)
                   .ContinueWith(
                       t =>
            {
                block.Dispose();
                Repository.Refs.Remotes.Refresh();
                var state2 = RefsState.Capture(Repository, ReferenceType.RemoteBranch);
                var changes = RefsDiff.Calculate(state1, state2);
                Repository.Remotes.OnPruneCompleted(this, changes);
                TaskUtility.PropagateFaultedStates(t);
            },
                       CancellationToken.None,
                       TaskContinuationOptions.ExecuteSynchronously,
                       TaskScheduler.Default));
        }
Пример #3
0
        public static async Task FetchOrPullAsync(
            Repository repository, Remote remote, bool pull,
            IProgress <OperationProgress> progress, CancellationToken cancellationToken)
        {
            var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag;

            if (pull)
            {
                affectedReferences |= ReferenceType.LocalBranch;
            }
            var suppressedNotifications = repository.Monitor.BlockNotifications(
                RepositoryNotifications.BranchChanged, RepositoryNotifications.TagChanged);
            var  state1 = RefsState.Capture(repository, affectedReferences);
            Task task;

            if (pull)
            {
                var p = new PullParameters();
                if (remote != null)
                {
                    p.Repository = remote.Name;
                }
                task = repository.Accessor.Pull.InvokeAsync(p, progress, cancellationToken);
            }
            else
            {
                var p = new FetchParameters();
                if (remote != null)
                {
                    p.Repository = remote.Name;
                }
                task = repository.Accessor.Fetch.InvokeAsync(p, progress, cancellationToken);
            }
            await task.ConfigureAwait(continueOnCapturedContext : false);

            progress?.Report(new OperationProgress(Resources.StrRefreshingReferences.AddEllipsis()));
            repository.Refs.Refresh(affectedReferences);
            var state2  = RefsState.Capture(repository, affectedReferences);
            var changes = RefsDiff.Calculate(state1, state2);

            suppressedNotifications.Dispose();
            if (changes != null && changes.Length != 0)
            {
                repository.OnUpdated();
            }

            if (pull)
            {
                repository.Remotes.OnPullCompleted(remote, changes);
            }
            else
            {
                repository.Remotes.OnFetchCompleted(remote, changes);
            }
            //return task.ContinueWith(
            //	t =>
            //	{
            //		progress?.Report(new OperationProgress(Resources.StrRefreshingReferences.AddEllipsis()));
            //		repository.Refs.Refresh(affectedReferences);
            //		var state2 = RefsState.Capture(repository, affectedReferences);
            //		var changes = RefsDiff.Calculate(state1, state2);
            //		suppressedNotifications.Dispose();
            //		if(changes != null && changes.Length != 0)
            //		{
            //			repository.OnUpdated();
            //		}
            //		TaskUtility.PropagateFaultedStates(t);
            //		if(pull)
            //		{
            //			repository.Remotes.OnPullCompleted(remote, changes);
            //		}
            //		else
            //		{
            //			repository.Remotes.OnFetchCompleted(remote, changes);
            //		}
            //	});
        }