Add darc vmr resolve operation

src/Microsoft.DotNet.Darc/Darc/Operations/VirtualMonoRepo/BackflowOperation.cs

@@ -8,9 +8,7 @@
 using Microsoft.DotNet.Darc.Options.VirtualMonoRepo;
 using Microsoft.DotNet.DarcLib;
 using Microsoft.DotNet.DarcLib.Helpers;
-using Microsoft.DotNet.DarcLib.Models.VirtualMonoRepo;
 using Microsoft.DotNet.DarcLib.VirtualMonoRepo;
-using Microsoft.DotNet.ProductConstructionService.Client.Models;
 using Microsoft.Extensions.Logging;
 
 #nullable enable
@@ -19,6 +17,7 @@ namespace Microsoft.DotNet.Darc.Operations.VirtualMonoRepo;
 internal class BackflowOperation(
     BackflowCommandLineOptions options,
     IVmrInfo vmrInfo,
+    IVmrForwardFlower forwardFlower,
     IVmrBackFlower backFlower,
     IBackflowConflictResolver backflowConflictResolver,
     IVmrCloneManager vmrCloneManager,
@@ -29,73 +28,40 @@ internal class BackflowOperation(
     IProcessManager processManager,
     IFileSystem fileSystem,
     ILogger<BackflowOperation> logger)
-    : CodeFlowOperation(options, vmrInfo, vmrCloneManager, dependencyTracker, dependencyFileManager, localGitRepoFactory, barApiClient, fileSystem, logger)
+    : CodeFlowOperation(options, forwardFlower, backFlower, backflowConflictResolver,  vmrInfo, vmrCloneManager, dependencyTracker, dependencyFileManager, localGitRepoFactory, barApiClient, fileSystem, logger)
 {
     private readonly BackflowCommandLineOptions _options = options;
     private readonly IVmrInfo _vmrInfo = vmrInfo;
-    private readonly IVmrBackFlower _backFlower = backFlower;
-    private readonly IBackflowConflictResolver _backflowConflictResolver = backflowConflictResolver;
     private readonly IProcessManager _processManager = processManager;
+    private readonly ILocalGitRepoFactory _localGitRepoFactory = localGitRepoFactory;
 
     protected override async Task ExecuteInternalAsync(
         string repoName,
         string? targetDirectory,
         IReadOnlyCollection<AdditionalRemote> additionalRemotes,
         CancellationToken cancellationToken)
     {
+
         if (string.IsNullOrEmpty(targetDirectory))
         {
             throw new DarcException("Please specify path to a local repository to flow to");
         }
 
-        _vmrInfo.VmrPath = new NativePath(_options.VmrPath ?? _processManager.FindGitRoot(Environment.CurrentDirectory));
+        var vmrPath = new NativePath(_options.VmrPath ?? _processManager.FindGitRoot(Environment.CurrentDirectory));
         var targetRepoPath = new NativePath(_processManager.FindGitRoot(targetDirectory));
 
+        _vmrInfo.VmrPath = vmrPath;
+
+        var vmr = _localGitRepoFactory.Create(vmrPath);
+
+        var build = await GetOrCreateBuildAsync(vmr, _options.Build);
+
         await FlowCodeLocallyAsync(
             targetRepoPath,
             isForwardFlow: false,
             additionalRemotes,
+            build,
+            subscription: null,
             cancellationToken);
     }
-
-    protected override async Task<bool> FlowCodeAsync(
-        ILocalGitRepo productRepo,
-        Build build,
-        Codeflow currentFlow,
-        SourceMapping mapping,
-        string headBranch,
-        IReadOnlyList<string> excludedAssets,
-        CancellationToken cancellationToken)
-    {
-        LastFlows lastFlows = await _backFlower.GetLastFlowsAsync(
-            mapping.Name,
-            productRepo,
-            currentIsBackflow: true);
-
-        try
-        {
-            var result = await _backFlower.FlowBackAsync(
-                mapping.Name,
-                productRepo.Path,
-                build,
-                excludedAssets: excludedAssets,
-                headBranch,
-                headBranch,
-                enableRebase: true,
-                forceUpdate: true,
-                cancellationToken);
-
-            return result.HadUpdates;
-        }
-        finally
-        {
-            await _backflowConflictResolver.TryMergingBranchAndUpdateDependencies(
-                new CodeflowOptions(mapping, currentFlow, headBranch, headBranch, build, excludedAssets, true, false),
-                lastFlows,
-                productRepo,
-                headBranch,
-                headBranchExisted: true,
-                cancellationToken);
-        }
-    }
 }

src/Microsoft.DotNet.Darc/Darc/Operations/VirtualMonoRepo/CodeFlowOperation.cs

@@ -20,6 +20,9 @@ namespace Microsoft.DotNet.Darc.Operations.VirtualMonoRepo;
 
 internal abstract class CodeFlowOperation(
         ICodeFlowCommandLineOptions options,
+        IVmrForwardFlower forwardFlower,
+        IVmrBackFlower backFlower,
+        IBackflowConflictResolver backflowConflictResolver,
         IVmrInfo vmrInfo,
         IVmrCloneManager vmrCloneManager,
         IVmrDependencyTracker dependencyTracker,
@@ -31,6 +34,9 @@ internal abstract class CodeFlowOperation(
     : VmrOperationBase(options, logger)
 {
     private readonly ICodeFlowCommandLineOptions _options = options;
+    private readonly IVmrForwardFlower _forwardFlower = forwardFlower;
+    private readonly IVmrBackFlower _backFlower = backFlower;
+    private readonly IBackflowConflictResolver _backflowConflictResolver = backflowConflictResolver;
     private readonly IVmrInfo _vmrInfo = vmrInfo;
     private readonly IVmrCloneManager _vmrCloneManager = vmrCloneManager;
     private readonly IVmrDependencyTracker _dependencyTracker = dependencyTracker;
@@ -44,6 +50,8 @@ protected async Task FlowCodeLocallyAsync(
         NativePath repoPath,
         bool isForwardFlow,
         IReadOnlyCollection<AdditionalRemote> additionalRemotes,
+        Build build,
+        Subscription? subscription,
         CancellationToken cancellationToken)
     {
         // If subscription ID is provided, fetch subscription metadata and populate options
@@ -57,7 +65,6 @@ protected async Task FlowCodeLocallyAsync(
         ILocalGitRepo sourceRepo = isForwardFlow ? productRepo : vmr;
         ILocalGitRepo targetRepo = isForwardFlow ? vmr : productRepo;
 
-        Build build = await GetBuildAsync(sourceRepo.Path);
         string mappingName = await GetSourceMappingNameAsync(productRepo.Path);
 
         await VerifyLocalRepositoriesAsync(productRepo);
@@ -94,22 +101,42 @@ protected async Task FlowCodeLocallyAsync(
 
         try
         {
-            bool hasChanges = await FlowCodeAsync(
-                productRepo,
-                build,
-                currentFlow,
-                mapping,
-                currentTargetRepoBranch,
-                excludedAssets,
-                cancellationToken);
+            bool hasChanges;
+            if (currentFlow is ForwardFlow)
+            {
+                hasChanges = await FlowForwardAsync(
+                    productRepo,
+                    build,
+                    currentFlow,
+                    mapping,
+                    currentTargetRepoBranch,
+                    excludedAssets,
+                    subscription?.TargetRepository,
+                    cancellationToken);
+            }
+            else
+            {
+                hasChanges = await FlowBackAsync(
+                    productRepo,
+                    build,
+                    currentFlow,
+                    mapping,
+                    currentTargetRepoBranch,
+                    excludedAssets,
+                    cancellationToken);
+            }
 
             if (!hasChanges)
             {
-                _logger.LogInformation("No changes to flow between the VMR and {repo}.", mapping.Name);
-                return;
-            }
 
-            _logger.LogInformation("Changes staged in {repoPath}", targetRepo.Path);
+                if (!hasChanges)
+                {
+                    _logger.LogInformation("No changes to flow between the VMR and {repo}.", mapping.Name);
+                    return;
+                }
+
+                _logger.LogInformation("Changes staged in {repoPath}", targetRepo.Path);
+            }
         }
         finally
         {
@@ -143,21 +170,10 @@ private async Task RestoreRepoToOriginalStateAsync(ILocalGitRepo repo, string or
         }
     }
 
-    protected abstract Task<bool> FlowCodeAsync(
-        ILocalGitRepo productRepo,
-        Build build,
-        Codeflow currentFlow,
-        SourceMapping mapping,
-        string headBranch,
-        IReadOnlyList<string> excludedAssets,
-        CancellationToken cancellationToken);
-
-    private async Task<Build> GetBuildAsync(NativePath sourceRepoPath)
+    protected async Task<Build> GetOrCreateBuildAsync(ILocalGitRepo sourceRepo, int buildId)
     {
-        ILocalGitRepo sourceRepo = _localGitRepoFactory.Create(sourceRepoPath);
-
         Build build;
-        if (_options.Build == 0)
+        if (buildId == 0)
         {
             _options.Ref = await sourceRepo.GetShaForRefAsync(_options.Ref);
             build = new(-1, DateTimeOffset.Now, 0, false, false, _options.Ref, [], [], [], [])
@@ -167,7 +183,7 @@ private async Task<Build> GetBuildAsync(NativePath sourceRepoPath)
         }
         else
         {
-            build = await _barApiClient.GetBuildAsync(_options.Build);
+            build = await _barApiClient.GetBuildAsync(buildId);
 
             try
             {
@@ -184,6 +200,92 @@ private async Task<Build> GetBuildAsync(NativePath sourceRepoPath)
         return build;
     }
 
+    protected async Task<bool> FlowForwardAsync(
+        ILocalGitRepo productRepo,
+        Build build,
+        Codeflow currentFlow,
+        SourceMapping mapping,
+        string headBranch,
+        IReadOnlyList<string> excludedAssets,
+        string? targetRepoUri,
+        CancellationToken cancellationToken)
+    {
+        if (targetRepoUri == null)
+        {
+            var vmr = _localGitRepoFactory.Create(_vmrInfo.VmrPath);
+            var remotes = await vmr.GetRemotesAsync();
+            targetRepoUri = remotes.First().Uri;
+        }
+
+        try
+        {
+            CodeFlowResult result = await _forwardFlower.FlowForwardAsync(
+                mapping.Name,
+                productRepo.Path,
+                build,
+                excludedAssets: excludedAssets,
+                headBranch,
+                headBranch,
+                targetRepoUri,
+                enableRebase: true,
+                forceUpdate: true,
+                cancellationToken);
+
+            return result.HadUpdates;
+        }
+        finally
+        {
+            // Update target branch's source manifest with the new commit
+            var vmr = _localGitRepoFactory.Create(_vmrInfo.VmrPath);
+            var sourceManifestContent = await vmr.GetFileFromGitAsync(VmrInfo.DefaultRelativeSourceManifestPath, headBranch);
+            var sourceManifest = SourceManifest.FromJson(sourceManifestContent!);
+            sourceManifest.UpdateVersion(mapping.Name, build.GetRepository(), build.Commit, build.Id);
+            _fileSystem.WriteToFile(_vmrInfo.SourceManifestPath, sourceManifest.ToJson());
+            await vmr.StageAsync([_vmrInfo.SourceManifestPath], cancellationToken);
+        }
+    }
+
+    protected async Task<bool> FlowBackAsync(
+        ILocalGitRepo productRepo,
+        Build build,
+        Codeflow currentFlow,
+        SourceMapping mapping,
+        string headBranch,
+        IReadOnlyList<string> excludedAssets,
+        CancellationToken cancellationToken)
+    {
+        LastFlows lastFlows = await _backFlower.GetLastFlowsAsync(
+            mapping.Name,
+            productRepo,
+            currentIsBackflow: true);
+
+        try
+        {
+            var result = await _backFlower.FlowBackAsync(
+                mapping.Name,
+                productRepo.Path,
+                build,
+                excludedAssets: excludedAssets,
+                headBranch,
+                headBranch,
+                enableRebase: true,
+                forceUpdate: true,
+                cancellationToken);
+
+            return result.HadUpdates;
+        }
+        finally
+        {
+            await _backflowConflictResolver.TryMergingBranchAndUpdateDependencies(
+                new CodeflowOptions(mapping, currentFlow, headBranch, headBranch, build, excludedAssets, true, false),
+                lastFlows,
+                productRepo,
+                headBranch,
+                headBranchExisted: true,
+                cancellationToken);
+        }
+    }
+
     protected async Task VerifyLocalRepositoriesAsync(ILocalGitRepo repo)
     {
         var vmr = _localGitRepoFactory.Create(_vmrInfo.VmrPath);