[Rollout] Production rollout 2025-05-22 (#4874)

#4873

Author: premun

src/Maestro/Maestro.MergePolicies/DependencyUpdateSummary.cs

@@ -26,11 +26,11 @@ public class DependencyUpdateSummary
 
     public DependencyUpdateSummary(DependencyUpdate du)
     {
-        DependencyName = du.To.Name;
-        FromVersion = du.From.Version;
-        ToVersion = du.To.Version;
-        FromCommitSha = du.From.Commit;
-        ToCommitSha = du.To.Commit;
+        DependencyName = du.To?.Name;
+        FromVersion = du.From?.Version;
+        ToVersion = du.To?.Version;
+        FromCommitSha = du.From?.Commit;
+        ToCommitSha = du.To?.Commit;
     }
 
     public DependencyUpdateSummary() { }

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

@@ -0,0 +1,96 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.DotNet.Darc.Options;
+using Microsoft.DotNet.DarcLib;
+using Microsoft.DotNet.ProductConstructionService.Client;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace Microsoft.DotNet.Darc.Operations;
+
+internal class UpdateChannelOperation : Operation
+{
+    private readonly UpdateChannelCommandLineOptions _options;
+    private readonly IBarApiClient _barClient;
+    private readonly ILogger<UpdateChannelOperation> _logger;
+
+    public UpdateChannelOperation(
+        UpdateChannelCommandLineOptions options,
+        IBarApiClient barClient,
+        ILogger<UpdateChannelOperation> logger)
+    {
+        _options = options;
+        _barClient = barClient;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Updates an existing channel's metadata (name and/or classification).
+    /// </summary>
+    /// <returns>Process exit code.</returns>
+    public override async Task<int> ExecuteAsync()
+    {
+        try
+        {
+            // Validate that at least one of name or classification is provided
+            if (string.IsNullOrEmpty(_options.Name) && string.IsNullOrEmpty(_options.Classification))
+            {
+                _logger.LogError("Either --name or --classification (or both) must be specified.");
+                return Constants.ErrorCode;
+            }
+
+            // Retrieve the current channel information first to confirm it exists
+            var channel = await _barClient.GetChannelAsync(_options.Id);
+            if (channel == null)
+            {
+                _logger.LogError("Could not find a channel with id '{id}'", _options.Id);
+                return Constants.ErrorCode;
+            }
+
+            // Update the channel with the specified information
+            var updatedChannel = await _barClient.UpdateChannelAsync(_options.Id, _options.Name, _options.Classification);
+
+            switch (_options.OutputFormat)
+            {
+                case DarcOutputType.json:
+                    Console.WriteLine(JsonConvert.SerializeObject(
+                        new
+                        {
+                            id = updatedChannel.Id,
+                            name = updatedChannel.Name,
+                            classification = updatedChannel.Classification
+                        },
+                        Formatting.Indented));
+                    break;
+                case DarcOutputType.text:
+                    Console.WriteLine($"Successfully updated channel '{_options.Id}':");
+                    Console.WriteLine($"  Name: {updatedChannel.Name}");
+                    Console.WriteLine($"  Classification: {updatedChannel.Classification}");
+                    break;
+                default:
+                    throw new NotImplementedException($"Output type {_options.OutputFormat} not supported by update-channel");
+            }
+
+            return Constants.SuccessCode;
+        }
+        catch (AuthenticationException e)
+        {
+            Console.WriteLine(e.Message);
+            return Constants.ErrorCode;
+        }
+        catch (RestApiException e) when (e.Response.Status == (int)HttpStatusCode.Conflict)
+        {
+            _logger.LogError($"A channel with the specified name already exists.");
+            return Constants.ErrorCode;
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Error: Failed to update channel.");
+            return Constants.ErrorCode;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using CommandLine;
+using Microsoft.DotNet.Darc.Operations;
+
+namespace Microsoft.DotNet.Darc.Options;
+
+[Verb("update-channel", HelpText = "Update an existing channel's metadata.")]
+internal class UpdateChannelCommandLineOptions : CommandLineOptions<UpdateChannelOperation>
+{
+    [Option('i', "id", Required = true, HelpText = "Channel ID.")]
+    public int Id { get; set; }
+
+    [Option('n', "name", HelpText = "New name of channel.")]
+    public string Name { get; set; }
+
+    [Option('c', "classification", HelpText = "New classification of channel.")]
+    public string Classification { get; set; }
+}

src/Microsoft.DotNet.Darc/Darc/Program.cs

@@ -115,6 +115,7 @@ public static Type[] GetOptions() =>
         typeof(SubscriptionsStatusCommandLineOptions),
         typeof(TriggerSubscriptionsCommandLineOptions),
         typeof(UpdateBuildCommandLineOptions),
+        typeof(UpdateChannelCommandLineOptions),
         typeof(UpdateDependenciesCommandLineOptions),
         typeof(UpdateSubscriptionCommandLineOptions),
         typeof(VerifyCommandLineOptions),

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

@@ -142,6 +142,18 @@ public Task<Channel> DeleteChannelAsync(int id)
         return _barClient.Channels.DeleteChannelAsync(id);
     }
 
+    /// <summary>
+    ///     Update a channel with new metadata.
+    /// </summary>
+    /// <param name="id">Id of channel to update</param>
+    /// <param name="name">Optional new name of channel</param>
+    /// <param name="classification">Optional new classification of channel</param>
+    /// <returns>Updated channel</returns>
+    public Task<Channel> UpdateChannelAsync(int id, string? name = null, string? classification = null)
+    {
+        return _barClient.Channels.UpdateChannelAsync(id, classification, name);
+    }
+
     public async Task<DependencyFlowGraph> GetDependencyFlowGraphAsync(
         int channelId,
         int days,

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

@@ -162,6 +162,15 @@ Task<Subscription> CreateSubscriptionAsync(
     /// <returns>Channel just deleted</returns>
     Task<Channel> DeleteChannelAsync(int id);
 
+    /// <summary>
+    ///     Update a channel with new metadata.
+    /// </summary>
+    /// <param name="id">Id of channel to update</param>
+    /// <param name="name">Optional new name of channel</param>
+    /// <param name="classification">Optional new classification of channel</param>
+    /// <returns>Updated channel</returns>
+    Task<Channel> UpdateChannelAsync(int id, string? name = null, string? classification = null);
+
     /// <summary>
     ///     Retrieve the list of channels from the build asset registry.
     /// </summary>

src/Microsoft.DotNet.Darc/DarcLib/VirtualMonoRepo/VersionFileCodeFlowUpdater.cs

@@ -242,6 +242,22 @@ async Task AbortMerge()
                 string.Join(", ", unresolvableConflicts));
 
             await AbortMerge();
+
+            // If this is a first commit, we need to update dependencies still
+            if (!headBranchExisted)
+            {
+                var updates = await BackflowDependenciesAndToolset(
+                    mapping.Name,
+                    repo,
+                    branchToMerge,
+                    build,
+                    excludedAssetsMatcher,
+                    lastFlow,
+                    (Backflow)currentFlow,
+                    cancellationToken);
+                return new VersionFileUpdateResult(ConflictedFiles: [.. conflictedFiles.Select(file => new UnixPath(file))], updates);
+            }
+
             return new VersionFileUpdateResult([..conflictedFiles.Select(file => new UnixPath(file))], []);
         }
 

src/ProductConstructionService/Microsoft.DotNet.ProductConstructionService.Client/Generated/Channels.cs

@@ -42,6 +42,13 @@ Task<List<string>> ListRepositoriesAsync(
             CancellationToken cancellationToken = default
         );
 
+        Task<Models.Channel> UpdateChannelAsync(
+            int id,
+            string classification = default,
+            string name = default,
+            CancellationToken cancellationToken = default
+        );
+
         Task AddBuildToChannelAsync(
             int buildId,
             int channelId,
@@ -455,6 +462,86 @@ internal async Task OnDeleteChannelFailed(Request req, Response res)
             throw ex;
         }
 
+        partial void HandleFailedUpdateChannelRequest(RestApiException ex);
+
+        public async Task<Models.Channel> UpdateChannelAsync(
+            int id,
+            string classification = default,
+            string name = default,
+            CancellationToken cancellationToken = default
+        )
+        {
+
+            const string apiVersion = "2020-02-20";
+
+            var _baseUri = Client.Options.BaseUri;
+            var _url = new RequestUriBuilder();
+            _url.Reset(_baseUri);
+            _url.AppendPath(
+                "/api/channels/{id}".Replace("{id}", Uri.EscapeDataString(Client.Serialize(id))),
+                false);
+
+            if (!string.IsNullOrEmpty(name))
+            {
+                _url.AppendQuery("name", Client.Serialize(name));
+            }
+            if (!string.IsNullOrEmpty(classification))
+            {
+                _url.AppendQuery("classification", Client.Serialize(classification));
+            }
+            _url.AppendQuery("api-version", Client.Serialize(apiVersion));
+
+
+            using (var _req = Client.Pipeline.CreateRequest())
+            {
+                _req.Uri = _url;
+                _req.Method = RequestMethod.Patch;
+
+                using (var _res = await Client.SendAsync(_req, cancellationToken).ConfigureAwait(false))
+                {
+                    if (_res.Status < 200 || _res.Status >= 300)
+                    {
+                        await OnUpdateChannelFailed(_req, _res).ConfigureAwait(false);
+                    }
+
+                    if (_res.ContentStream == null)
+                    {
+                        await OnUpdateChannelFailed(_req, _res).ConfigureAwait(false);
+                    }
+
+                    using (var _reader = new StreamReader(_res.ContentStream))
+                    {
+                        var _content = await _reader.ReadToEndAsync().ConfigureAwait(false);
+                        var _body = Client.Deserialize<Models.Channel>(_content);
+                        return _body;
+                    }
+                }
+            }
+        }
+
+        internal async Task OnUpdateChannelFailed(Request req, Response res)
+        {
+            string content = null;
+            if (res.ContentStream != null)
+            {
+                using (var reader = new StreamReader(res.ContentStream))
+                {
+                    content = await reader.ReadToEndAsync().ConfigureAwait(false);
+                }
+            }
+
+            var ex = new RestApiException<Models.ApiError>(
+                req,
+                res,
+                content,
+                Client.Deserialize<Models.ApiError>(content)
+                );
+            HandleFailedUpdateChannelRequest(ex);
+            HandleFailedRequest(ex);
+            Client.OnFailedRequest(ex);
+            throw ex;
+        }
+
         partial void HandleFailedAddBuildToChannelRequest(RestApiException ex);
 
         public async Task AddBuildToChannelAsync(

src/ProductConstructionService/ProductConstructionService.Api/Api/v2018_07_16/Controllers/ChannelsController.cs

@@ -238,6 +238,44 @@ public virtual async Task<IActionResult> RemoveBuildFromChannel(int channelId, i
         return StatusCode((int)HttpStatusCode.OK);
     }
 
+    /// <summary>
+    ///   Update metadata of a <see cref="Channel"/>.
+    /// </summary>
+    /// <param name="id">The id of the <see cref="Channel"/> to update</param>
+    /// <param name="name">Optional new name of the <see cref="Channel"/></param>
+    /// <param name="classification">Optional new classification of the <see cref="Channel"/></param>
+    [HttpPatch("{id}")]
+    [SwaggerApiResponse(HttpStatusCode.OK, Type = typeof(Channel), Description = "The Channel has been updated")]
+    [SwaggerApiResponse(HttpStatusCode.BadRequest, Description = "At least one of name or classification must be specified")]
+    [SwaggerApiResponse(HttpStatusCode.Conflict, Description = "A Channel with that name already exists")]
+    [HandleDuplicateKeyRows("Could not update channel. A channel with the specified name already exists.")]
+    public virtual async Task<IActionResult> UpdateChannel(int id, string? name = null, string? classification = null)
+    {
+        if (string.IsNullOrEmpty(name) && string.IsNullOrEmpty(classification))
+        {
+            return BadRequest(new ApiError("At least one of 'name' or 'classification' must be specified."));
+        }
+
+        Maestro.Data.Models.Channel? channel = await _context.Channels.FindAsync(id);
+        if (channel == null)
+        {
+            return NotFound();
+        }
+
+        if (!string.IsNullOrEmpty(name))
+        {
+            channel.Name = name;
+        }
+
+        if (!string.IsNullOrEmpty(classification))
+        {
+            channel.Classification = classification;
+        }
+
+        await _context.SaveChangesAsync();
+        return Ok(new Channel(channel));
+    }
+
     /// <summary>
     ///   Add an existing <see cref="ReleasePipeline"/> to the specified <see cref="Channel"/>
     /// </summary>

src/ProductConstructionService/ProductConstructionService.Api/Api/v2020_02_20/Controllers/ChannelsController.cs

@@ -237,6 +237,22 @@ public override async Task<IActionResult> RemoveBuildFromChannel(int channelId,
         return StatusCode((int)HttpStatusCode.OK);
     }
 
+    /// <summary>
+    ///   Update metadata of a <see cref="Channel"/>.
+    /// </summary>
+    /// <param name="id">The id of the <see cref="Channel"/> to update</param>
+    /// <param name="name">Optional new name of the <see cref="Channel"/></param>
+    /// <param name="classification">Optional new classification of the <see cref="Channel"/></param>
+    [HttpPatch("{id}")]
+    [SwaggerApiResponse(HttpStatusCode.OK, Type = typeof(Channel), Description = "The Channel has been updated")]
+    [SwaggerApiResponse(HttpStatusCode.BadRequest, Description = "At least one of name or classification must be specified")]
+    [SwaggerApiResponse(HttpStatusCode.Conflict, Description = "A Channel with that name already exists")]
+    [HandleDuplicateKeyRows("Could not update channel. A channel with the specified name already exists.")]
+    public override async Task<IActionResult> UpdateChannel(int id, string? name = null, string? classification = null)
+    {
+        return await base.UpdateChannel(id, name, classification);
+    }
+
     [ApiRemoved]
     public override Task<IActionResult> AddPipelineToChannel(int channelId, int pipelineId)
     {