feat: Refactor DockerComposePublishingContext for clarity (#8563)

Update property access to use `PublisherOptions` directly for 
consistency. Introduce a new option to control image building during 
the publishing process. Ensure that image building only occurs when 
enabled. Adjust tests to accommodate these changes.

Author: prom3theu5

src/Aspire.Hosting.Docker/DockerComposePublisherOptions.cs

@@ -19,4 +19,9 @@ public sealed class DockerComposePublisherOptions : PublishingOptions
     /// The name of an existing network to be used.
     /// </summary>
     public string? ExistingNetworkName { get; set; }
+
+    /// <summary>
+    /// Indicates whether to build container images during the publishing process.
+    /// </summary>
+    public bool BuildImages { get; set; } = true;
 }

src/Aspire.Hosting.Docker/DockerComposePublishingContext.cs

@@ -30,7 +30,7 @@ internal sealed class DockerComposePublishingContext(
     CancellationToken cancellationToken = default)
 {
     public readonly IResourceContainerImageBuilder ImageBuilder = imageBuilder;
-
+    public readonly DockerComposePublisherOptions PublisherOptions = publisherOptions;
     public readonly PortAllocator PortAllocator = new();
     private readonly Dictionary<string, (string Description, string? DefaultValue)> _env = [];
     private readonly Dictionary<IResource, ComposeServiceContext> _composeServices = [];
@@ -48,7 +48,7 @@ internal async Task WriteModelAsync(DistributedApplicationModel model)
         logger.StartGeneratingDockerCompose();
 
         ArgumentNullException.ThrowIfNull(model);
-        ArgumentNullException.ThrowIfNull(publisherOptions.OutputPath);
+        ArgumentNullException.ThrowIfNull(PublisherOptions.OutputPath);
 
         if (model.Resources.Count == 0)
         {
@@ -58,7 +58,7 @@ internal async Task WriteModelAsync(DistributedApplicationModel model)
 
         await WriteDockerComposeOutputAsync(model).ConfigureAwait(false);
 
-        logger.FinishGeneratingDockerCompose(publisherOptions.OutputPath);
+        logger.FinishGeneratingDockerCompose(PublisherOptions.OutputPath);
     }
 
     public void AddEnv(string name, string description, string? defaultValue = null)
@@ -70,7 +70,7 @@ private async Task WriteDockerComposeOutputAsync(DistributedApplicationModel mod
     {
         var defaultNetwork = new Network
         {
-            Name = publisherOptions.ExistingNetworkName ?? "aspire",
+            Name = PublisherOptions.ExistingNetworkName ?? "aspire",
             Driver = "bridge",
         };
 
@@ -105,8 +105,8 @@ private async Task WriteDockerComposeOutputAsync(DistributedApplicationModel mod
         }
 
         var composeOutput = composeFile.ToYaml();
-        var outputFile = Path.Combine(publisherOptions.OutputPath!, "docker-compose.yaml");
-        Directory.CreateDirectory(publisherOptions.OutputPath!);
+        var outputFile = Path.Combine(PublisherOptions.OutputPath!, "docker-compose.yaml");
+        Directory.CreateDirectory(PublisherOptions.OutputPath!);
         await File.WriteAllTextAsync(outputFile, composeOutput, cancellationToken).ConfigureAwait(false);
 
         if (_env.Count == 0)
@@ -117,7 +117,7 @@ private async Task WriteDockerComposeOutputAsync(DistributedApplicationModel mod
 
         // Write a .env file with the environment variable names
         // that are used in the compose file
-        var envFile = Path.Combine(publisherOptions.OutputPath!, ".env");
+        var envFile = Path.Combine(PublisherOptions.OutputPath!, ".env");
         using var envWriter = new StreamWriter(envFile);
 
         foreach (var entry in _env)
@@ -200,7 +200,10 @@ private record struct EndpointMapping(string Scheme, string Host, int InternalPo
 
         public async Task<Service> BuildComposeServiceAsync(CancellationToken cancellationToken)
         {
-            await composePublishingContext.ImageBuilder.BuildImageAsync(resource, cancellationToken).ConfigureAwait(false);
+            if (composePublishingContext.PublisherOptions.BuildImages)
+            {
+                await composePublishingContext.ImageBuilder.BuildImageAsync(resource, cancellationToken).ConfigureAwait(false);
+            }
 
             if (!TryGetContainerImageName(resource, out var containerImageName))
             {

tests/Aspire.Hosting.Docker.Tests/DockerComposePublisherTests.cs

@@ -61,7 +61,8 @@ public async Task PublishAsync_GeneratesValidDockerComposeFile()
 
         await ExecuteBeforeStartHooksAsync(app, default);
 
-        var publisher = new DockerComposePublisher("test", options,
+        var publisher = new DockerComposePublisher("test",
+            options,
             NullLogger<DockerComposePublisher>.Instance,
             builder.ExecutionContext,
             new MockImageBuilder()
@@ -130,7 +131,7 @@ public async Task PublishAsync_GeneratesValidDockerComposeFile()
             networks:
               aspire:
                 driver: "bridge"
-            
+
             """,
             content, ignoreAllWhiteSpace: true, ignoreLineEndingDifferences: true);
 
@@ -195,13 +196,60 @@ public async Task DockerComposeCorrectlyEmitsPortMappings()
             content, ignoreAllWhiteSpace: true, ignoreLineEndingDifferences: true);
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task DockerComposeHandleImageBuilding(bool shouldBuildImages)
+    {
+        using var tempDir = new TempDirectory();
+        using var builder = TestDistributedApplicationBuilder.Create(["--operation", "publish", "--publisher", "docker-compose", "--output-path", tempDir.Path])
+            .WithTestAndResourceLogging(outputHelper);
+
+        var options = new OptionsMonitor(new DockerComposePublisherOptions
+        {
+            OutputPath = tempDir.Path,
+            BuildImages = shouldBuildImages,
+        });
+
+        var mockImageBuilder = new MockImageBuilder();
+
+        builder.AddDockerComposePublisher();
+
+        builder.AddContainer("resource", "mcr.microsoft.com/dotnet/aspnet:8.0")
+            .WithEnvironment("ASPNETCORE_ENVIRONMENT", "Development")
+            .WithHttpEndpoint(env: "HTTP_PORT");
+
+        var app = builder.Build();
+
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        await ExecuteBeforeStartHooksAsync(app, CancellationToken.None);
+
+        var publisher = new DockerComposePublisher("test",
+            options,
+            NullLogger<DockerComposePublisher>.Instance,
+            builder.ExecutionContext,
+            mockImageBuilder
+        );
+
+        // Act
+        await publisher.PublishAsync(model, CancellationToken.None);
+
+        var composePath = Path.Combine(tempDir.Path, "docker-compose.yaml");
+        Assert.True(File.Exists(composePath));
+        Assert.Equal(shouldBuildImages, mockImageBuilder.BuildImageCalled);
+    }
+
     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "ExecuteBeforeStartHooksAsync")]
     private static extern Task ExecuteBeforeStartHooksAsync(DistributedApplication app, CancellationToken cancellationToken);
 
     private sealed class MockImageBuilder : IResourceContainerImageBuilder
     {
+        public bool BuildImageCalled { get; private set; }
+
         public Task BuildImageAsync(IResource resource, CancellationToken cancellationToken)
         {
+            BuildImageCalled = true;
             return Task.CompletedTask;
         }
     }