protected override async Task RunProcess() { if (mode == DeleteBranchMode.ActualBranchOnly) { await AppendProcess(cli.DeleteRemote(deletingBranch)).WaitUntilComplete(); await repository.BranchUpdated(deletingBranch, null, await repository.GetBranchRef(deletingBranch).Take(1)); } else { var details = await repository.GetBranchDetails(deletingBranch).FirstAsync(); using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork()) { settings.DeleteBranchSettings(deletingBranch, unitOfWork); await unitOfWork.CommitAsync(); } if (mode != DeleteBranchMode.GroupOnly) { foreach (var branch in details.Branches) { await AppendProcess(cli.DeleteRemote(branch.Name)).WaitUntilComplete(); await repository.BranchUpdated(branch.Name, null, await repository.GetBranchRef(branch.Name).Take(1)); } } } }
public MergeDownstreamActionProcess(IGitCli cli, IGitServiceApi gitServiceApi, IUnitOfWorkFactory workFactory, IRepositoryOrchestration orchestration, IRepositoryMediator repository, IntegrateBranchesOrchestration integrateBranches, IBranchIterationMediator branchIteration, string downstreamBranch, IOptions <GitRepositoryOptions> options, IMergeStrategyManager strategyManager) { this.cli = cli; this.gitServiceApi = gitServiceApi; this.integrateBranches = integrateBranches; this.repository = repository; this.orchestration = orchestration; this.branchIteration = branchIteration; this.downstreamBranchGroup = downstreamBranch; this.detailsTask = repository.GetBranchDetails(downstreamBranch).FirstAsync().ToTask(); this.latestBranchName = detailsTask.ContinueWith(task => repository.LatestBranchName(task.Result).FirstOrDefaultAsync().ToTask()).Unwrap(); this.strategyTask = detailsTask.ContinueWith(task => strategyManager.GetMergeStrategy(task.Result)); this.isReadOnly = options.Value.ReadOnly; this.workFactory = workFactory; }
protected override async Task RunProcess() { var targetBranch = await repository.GetBranchDetails(newBaseBranch).FirstOrDefaultAsync(); // 1. make sure everything is already merged // 2. run consolidate branches SQL // 3. delete old branches ImmutableList <BranchGroupCompleteData> branchesToRemove = await GetBranchesToRemove(targetBranch); if (await MergesInProgress(targetBranch, branchesToRemove)) { // abort, but queue another attempt #pragma warning disable CS4014 orchestration.EnqueueAction(new ConsolidateMergedAction(sourceBranch: sourceBranch, newBaseBranch: newBaseBranch), skipDuplicateCheck: true); #pragma warning restore await AppendMessage($"Merges were still in queue, deferring consolidation to {newBaseBranch} from {sourceBranch}.", isError : true); return; } await AppendMessage($"Consolidating to {newBaseBranch} from {sourceBranch}, removing: {string.Join(", ", branchesToRemove.Select(b => b.GroupName))}.", isError : true); // Integration branches remain separate. Even if they have one // parent, multiple things could depend on them and you don't // want to flatten out those commits too early. using (var unitOfWork = workFactory.CreateUnitOfWork()) { repository.ConsolidateBranches(branchesToRemove.Select(b => b.GroupName), targetBranch.GroupName, unitOfWork); await unitOfWork.CommitAsync(); } // TODO - branches could get deleted here that were ignored in the `ConsolidateBranches` logic. await(from branch in branchesToRemove.ToObservable() from actualBranch in branch.Branches from entry in AppendProcess(cli.DeleteRemote(actualBranch.Name)).WaitUntilComplete().ContinueWith <int>((t) => 0) select entry); repository.CheckForUpdates(); }
protected override async Task RunProcess() { if (isReadOnly) { return; } // either: // 1. create new service line from release candidate // 2. merge --ff-only from release candidate to service line // if it passes: // collect upstream branches // push service line var upstreamLines = await repository.DetectShallowUpstreamServiceLines(releaseCandidateBranch).FirstOrDefaultAsync(); var disposable = new CompositeDisposable(); var readyToFinalize = await CreateOrFastForwardServiceLine(releaseCandidateBranch, repository, cli); if (!readyToFinalize) { await AppendMessage($"{serviceLineBranch} unable to be fast-forwarded from {releaseCandidateBranch}; aborting", isError : true); } else { if (!string.IsNullOrEmpty(tagName)) { await AppendProcess(cli.AnnotatedTag(tagName, $"Automated release to service line {serviceLineBranch} from {releaseCandidateBranch}")).WaitUntilComplete(); } var serviceLine = await settings.GetBranchBasicDetails(serviceLineBranch).FirstOrDefaultAsync(); // possible TODO for the future: give option to add missing upstream lines always if (serviceLine == null) { // We need to set it up as a service line using (var work = unitOfWorkFactory.CreateUnitOfWork()) { settings.UpdateBranchSetting(serviceLineBranch, UpstreamMergePolicy.None, BranchGroupType.ServiceLine, work); foreach (var upstreamServiceLine in upstreamLines) { settings.AddBranchPropagation(upstreamServiceLine, serviceLineBranch, work); } await work.CommitAsync(); } } if (autoConsolidate) { var consolidating = (await repository.GetBranchDetails(releaseCandidateBranch).FirstOrDefaultAsync()).UpstreamBranchGroups; foreach (var upstreamServiceLine in upstreamLines) { var upstreamDetails = await repository.GetBranchDetails(upstreamServiceLine).FirstOrDefaultAsync(); consolidating = consolidating.Except(upstreamDetails.UpstreamBranchGroups).Except(new[] { upstreamServiceLine }).ToImmutableList(); } var releasedCandidate = await settings.GetConfiguredBranches().Select(branches => branches.Find(branch => branchIteration.IsBranchIteration(branch.GroupName, releaseCandidateBranch)).GroupName).FirstOrDefaultAsync(); #pragma warning disable CS4014 orchestration.EnqueueAction(new ConsolidateMergedAction(releasedCandidate, serviceLineBranch)); #pragma warning restore } if (!string.IsNullOrEmpty(tagName)) { await AppendProcess(cli.Push(tagName)).WaitUntilComplete(); } await AppendProcess(cli.Push(serviceLineBranch)).WaitUntilComplete(); } }