Test PR to test copilot reviews

src/Microsoft.DotNet.Darc/Darc/Operations/GetChannelsOperation.cs

@@ -2,94 +2,176 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.DotNet.Darc.Options;
 using Microsoft.DotNet.DarcLib;
-using Microsoft.DotNet.Maestro.Client;
-using Microsoft.DotNet.Maestro.Client.Models;
+using Microsoft.DotNet.DarcLib.Helpers;
+using Microsoft.DotNet.DarcLib.Models.VirtualMonoRepo;
+using Microsoft.DotNet.DarcLib.VirtualMonoRepo;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
 
 namespace Microsoft.DotNet.Darc.Operations;
 
-internal class GetChannelsOperation : Operation
+class CodeFlowConflictResolver
 {
-    private readonly GetChannelsCommandLineOptions _options;
-    private readonly IBarApiClient _barClient;
-    private readonly ILogger<GetChannelOperation> _logger;
+    private readonly IVmrInfo _vmrInfo;
+    private readonly ILocalGitRepoFactory _localGitRepoFactory;
+    private readonly ISourceManifest _sourceManifest;
+    private readonly IFileSystem _fileSystem;
+    private readonly ILogger<CodeFlowConflictResolver> _logger;
 
-    public GetChannelsOperation(
-        GetChannelsCommandLineOptions options,
-        IBarApiClient barClient,
-        ILogger<GetChannelOperation> logger)
+    public CodeFlowConflictResolver(
+        IVmrInfo vmrInfo,
+        ILocalGitRepoFactory localGitRepoFactory,
+        ISourceManifest sourceManifest,
+        IFileSystem fileSystem,
+        ILogger<CodeFlowConflictResolver> logger)
     {
-        _options = options;
-        _barClient = barClient;
+        _vmrInfo = vmrInfo;
+        _localGitRepoFactory = localGitRepoFactory;
+        _sourceManifest = sourceManifest;
+        _fileSystem = fileSystem;
         _logger = logger;
     }
 
-    /// <summary>
-    /// Retrieve information about channels
-    /// </summary>
-    /// <param name="options">Command line options</param>
-    /// <returns>Process exit code.</returns>
-    public override async Task<int> ExecuteAsync()
+    public async Task<bool> TryMergingTargetBranch(string mappingName, string baseBranch, string targetBranch)
     {
-        try
+        var vmr = _localGitRepoFactory.Create(_vmrInfo.VmrPath);
+        await vmr.CheckoutAsync(baseBranch);
+        var result = await vmr.RunGitCommandAsync(["merge", "--no-commit", "--no-ff", targetBranch]);
+        if (result.Succeeded)
+        {
+            _logger.LogInformation("Successfully merged the branch {targetBranch} into {headBranch} in {repoPath}",
+                targetBranch,
+                baseBranch,
+                _vmrInfo.VmrPath);
+            await vmr.CommitAsync($"Merging {targetBranch} into {baseBranch}", allowEmpty: true);
+            return true;
+        }
+
+        result = await vmr.RunGitCommandAsync(["diff", "--name-only", "--diff-filter=U", "--relative"]);
+        if (!result.Succeeded)
         {
-            var allChannels = await _barClient.GetChannelsAsync();
-            switch (_options.OutputFormat)
+            _logger.LogInformation("Failed to merge the branch {targetBranch} into {headBranch} in {repoPath}",
+                targetBranch,
+                baseBranch,
+                _vmrInfo.VmrPath);
+            result = await vmr.RunGitCommandAsync(["merge", "--abort"]);
+            return false;
+        }
+
+        var conflictedFiles = result.StandardOutput
+            .Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries)
+            .Select(line => new UnixPath(line.Trim()));
+
+        var gitInfoFile = VmrInfo.GitInfoSourcesDir + "/" + mappingName + ".props";
+
+        foreach (var file in conflictedFiles)
+        {
+            // Known conflict in source-manifest.json
+            if (file == VmrInfo.DefaultRelativeSourceManifestPath)
             {
-                case DarcOutputType.json:
-                    WriteJsonChannelList(allChannels);
-                    break;
-                case DarcOutputType.text:
-                    WriteYamlChannelList(allChannels);
-                    break;
-                default:
-                    throw new NotImplementedException($"Output format {_options.OutputFormat} not supported for get-channels");
+                await TryResolvingSourceManifestConflict(vmr, mappingName);
+                continue;
             }
 
-            return Constants.SuccessCode;
+            // Known conflict in a git-info props file - we just use our version as we expect it to be newer
+            // TODO: For batched subscriptions, we need to handle all git-info files
+            if (file == gitInfoFile)
+            {
+                await vmr.RunGitCommandAsync(["checkout", "--ours", file]);
+                await vmr.StageAsync([file]);
+                continue;
+            }
+
+            _logger.LogInformation("Failed to resolve conflicts in {file} between branches {targetBranch} and {headBranch} in {repoPath}",
+                file,
+                targetBranch,
+                baseBranch,
+                _vmrInfo.VmrPath);
+            result = await vmr.RunGitCommandAsync(["merge", "--abort"]);
+            return false;
         }
-        catch (AuthenticationException e)
+
+        _logger.LogInformation("Successfully resolved version file conflicts between branches {targetBranch} and {headBranch} in {repoPath}",
+            targetBranch,
+            baseBranch,
+            _vmrInfo.VmrPath);
+        await vmr.CommitAsync($"Resolving conflicts between {targetBranch} and {baseBranch}", allowEmpty: false);
+        return true;
+    }
+
+    // TODO: This won't work for batched subscriptions
+    private async Task TryResolvingSourceManifestConflict(ILocalGitRepo vmr, string mappingName)
+    {
+        // We load the source manifest from the target branch and replace the current mapping (and its submodules) with our branches' information
+        var result = await vmr.RunGitCommandAsync(["show", "MERGE_HEAD:" + VmrInfo.DefaultRelativeSourceManifestPath]);
+
+        var theirSourceManifest = SourceManifest.FromJson(result.StandardOutput);
+        var ourSourceManifest = _sourceManifest;
+        var updatedMapping = ourSourceManifest.Repositories.First(r => r.Path == mappingName);
+
+        theirSourceManifest.UpdateVersion(mappingName, updatedMapping.RemoteUri, updatedMapping.CommitSha, updatedMapping.PackageVersion, updatedMapping.BarId);
+
+        foreach (var submodule in theirSourceManifest.Submodules.Where(s => s.Path.StartsWith(mappingName + "/")))
         {
-            Console.WriteLine(e.Message);
-            return Constants.ErrorCode;
+            theirSourceManifest.RemoveSubmodule(submodule);
         }
-        catch (Exception e)
+
+        foreach (var submodule in _sourceManifest.Submodules.Where(s => s.Path.StartsWith(mappingName + "/")))
         {
-            _logger.LogError(e, "Error: Failed to retrieve channels");
-            return Constants.ErrorCode;
+            theirSourceManifest.UpdateSubmodule(submodule);
         }
+
+        _fileSystem.WriteToFile(_vmrInfo.SourceManifestPath, theirSourceManifest.ToJson());
+        _sourceManifest.Refresh(_vmrInfo.SourceManifestPath);
+        await vmr.StageAsync([_vmrInfo.SourceManifestPath]);
     }
+}
 
-    private static void WriteJsonChannelList(IEnumerable<Channel> allChannels)
+internal class GetChannelsOperation : Operation
+{
+    private readonly GetChannelsCommandLineOptions _options;
+    private readonly IVmrCloneManager _cloneManager;
+    private readonly IVmrInfo _vmrInfo;
+    private readonly CodeFlowConflictResolver _conflictResolver;
+
+    public GetChannelsOperation(
+        GetChannelsCommandLineOptions options,
+        IVmrCloneManager cloneManager,
+        IVmrInfo vmrInfo,
+        CodeFlowConflictResolver conflictResolver)
     {
-        var channelJson = new
-        {
-            channels = allChannels.OrderBy(c => c.Name).Select(channel =>
-                new
-                {
-                    id = channel.Id,
-                    name = channel.Name
-                })
-        };
-
-        Console.WriteLine(JsonConvert.SerializeObject(channelJson, Formatting.Indented));
+        _options = options;
+        _cloneManager = cloneManager;
+        _vmrInfo = vmrInfo;
+        _conflictResolver = conflictResolver;
     }
 
-    private static void WriteYamlChannelList(IEnumerable<Channel> allChannels)
+    /// <summary>
+    /// Retrieve information about channels
+    /// </summary>
+    /// <param name="options">Command line options</param>
+    /// <returns>Process exit code.</returns>
+    public override async Task<int> ExecuteAsync()
     {
-        // Write out a simple list of each channel's name
-        foreach (var channel in allChannels.OrderBy(c => c.Name))
+        var path = @"C:\Users\prvysoky\AppData\Local\Temp\_vmrTests\wvzmghdz.ec2\_tests\xeihkfov.lgk\vmr";
+        var targetBranch = "main";
+        var prBranch = "OutOfOrderMergesTest-ff";
+
+        _vmrInfo.VmrPath = new NativePath(path);
+        await _cloneManager.PrepareVmrAsync([path], [targetBranch, prBranch], prBranch, default);
+
+        if (await _conflictResolver.TryMergingTargetBranch("product-repo1", prBranch, targetBranch))
         {
-            // Pad so that id's up to 9999 will result in consistent
-            // listing
-            string idPrefix = $"({channel.Id})".PadRight(7);
-            Console.WriteLine($"{idPrefix}{channel.Name}");
+            Console.WriteLine("yay");
         }
+        else
+        {
+            Console.WriteLine("nay");
+        }
+
+        return Constants.SuccessCode;
     }
 }

src/Microsoft.DotNet.Darc/Darc/Options/CommandLineOptions.cs

@@ -10,6 +10,7 @@
 using Microsoft.DotNet.Darc.Operations;
 using Microsoft.DotNet.DarcLib;
 using Microsoft.DotNet.DarcLib.Helpers;
+using Microsoft.DotNet.DarcLib.VirtualMonoRepo;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
@@ -172,6 +173,8 @@ public virtual IServiceCollection RegisterServices(IServiceCollection services)
         );
         services.TryAddSingleton<IRemoteTokenProvider>(_ => new RemoteTokenProvider(AzureDevOpsPat, GitHubPat));
         services.TryAddSingleton<ICommandLineOptions>(_ => this);
+        services.AddTransient<CodeFlowConflictResolver>();
+        services.AddScoped<IVmrCloneManager, VmrCloneManager>();
 
         return services;
     }

src/Microsoft.DotNet.Darc/Darc/Options/GetChannelsCommandLineOptions.cs

@@ -3,11 +3,12 @@
 
 using CommandLine;
 using Microsoft.DotNet.Darc.Operations;
+using Microsoft.DotNet.Darc.Options.VirtualMonoRepo;
 
 namespace Microsoft.DotNet.Darc.Options;
 
 [Verb("get-channels", HelpText = "Get a list of channels.")]
-internal class GetChannelsCommandLineOptions : CommandLineOptions<GetChannelsOperation>
+internal class GetChannelsCommandLineOptions : VmrCommandLineOptions<GetChannelsOperation>
 {
     public override bool IsOutputFormatSupported()
         => OutputFormat switch

src/Microsoft.DotNet.Darc/DarcLib/ILocalGitRepo.cs

@@ -178,4 +178,9 @@ Task CommitAsync(
     /// <param name="args">Where to add the new argument into</param>
     /// <param name="envVars">Where to add the new variables into</param>
     public void AddGitAuthHeader(IList<string> args, IDictionary<string, string> envVars, string repoUri);
+
+    /// <summary>
+    /// Runs an arbitrary git command in the repo.
+    /// </summary>
+    Task<ProcessExecutionResult> RunGitCommandAsync(string[] args, CancellationToken cancellationToken = default);
 }

src/Microsoft.DotNet.Darc/DarcLib/LocalGitRepo.cs

@@ -86,6 +86,9 @@ public async Task SetConfigValue(string setting, string value)
     public async Task ResetWorkingTree(UnixPath? relativePath = null)
         => await _localGitClient.ResetWorkingTree(new NativePath(Path), relativePath);
 
+    public async Task<ProcessExecutionResult> RunGitCommandAsync(string[] args, CancellationToken cancellationToken = default)
+        => await _localGitClient.RunGitCommandAsync(Path, args, cancellationToken);
+
     public async Task StageAsync(IEnumerable<string> pathsToStage, CancellationToken cancellationToken = default)
         => await _localGitClient.StageAsync(Path, pathsToStage, cancellationToken);
 

src/Microsoft.DotNet.Darc/DarcLib/Models/VirtualMonoRepo/ManifestRecord.cs

@@ -56,6 +56,7 @@ public string GetPublicUrl()
 public interface IVersionedSourceComponent : ISourceComponent
 {
     string? PackageVersion { get; }
+    public int? BarId { get; }
 }
 
 /// <summary>

src/Microsoft.DotNet.Darc/DarcLib/Models/VirtualMonoRepo/SourceManifest.cs

@@ -19,8 +19,8 @@ public interface ISourceManifest
 
     string ToJson();
     void RemoveRepository(string repository);
-    void RemoveSubmodule(SubmoduleRecord submodule);
-    void UpdateSubmodule(SubmoduleRecord submodule);
+    void RemoveSubmodule(ISourceComponent submodule);
+    void UpdateSubmodule(ISourceComponent submodule);
     void UpdateVersion(string repository, string uri, string sha, string? packageVersion, int? barId);
     VmrDependencyVersion? GetVersion(string repository);
     bool TryGetRepoVersion(string mappingName, [NotNullWhen(true)] out ISourceComponent? mapping);
@@ -54,15 +54,8 @@ public void UpdateVersion(string repository, string uri, string sha, string? pac
         {
             repo.CommitSha = sha;
             repo.RemoteUri = uri;
-
-            if (packageVersion != null)
-            {
-                repo.PackageVersion = packageVersion;
-            }
-            if (barId != null)
-            {
-                repo.BarId = barId;
-            }
+            repo.PackageVersion = packageVersion;
+            repo.BarId = barId;
         }
         else
         {
@@ -81,7 +74,7 @@ public void RemoveRepository(string repository)
         _submodules.RemoveWhere(s => s.Path.StartsWith(repository + "/"));
     }
 
-    public void RemoveSubmodule(SubmoduleRecord submodule)
+    public void RemoveSubmodule(ISourceComponent submodule)
     {
         var repo = _submodules.FirstOrDefault(r => r.Path == submodule.Path);
         if (repo != null)
@@ -90,7 +83,7 @@ public void RemoveSubmodule(SubmoduleRecord submodule)
         }
     }
 
-    public void UpdateSubmodule(SubmoduleRecord submodule)
+    public void UpdateSubmodule(ISourceComponent submodule)
     {
         var repo = _submodules.FirstOrDefault(r => r.Path == submodule.Path);
         if (repo != null)
@@ -100,7 +93,7 @@ public void UpdateSubmodule(SubmoduleRecord submodule)
         }
         else
         {
-            _submodules.Add(submodule);
+            _submodules.Add(new SubmoduleRecord(submodule.Path, submodule.RemoteUri, submodule.CommitSha));
         }
     }