Fix Azure ServiceBus persistent container support

playground/AzureServiceBus/ServiceBus.AppHost/Program.cs

@@ -39,7 +39,7 @@
 serviceBus.RunAsEmulator(configure => configure.ConfigureEmulator(document =>
 {
     document["UserConfig"]!["Logging"] = new JsonObject { ["Type"] = "Console" };
-}));
+}).WithLifetime(ContainerLifetime.Persistent));
 
 builder.AddProject<Projects.ServiceBusWorker>("worker")
     .WithReference(serviceBus).WaitFor(serviceBus);

src/Aspire.Hosting.AppHost/build/Aspire.Hosting.AppHost.targets

@@ -241,6 +241,15 @@ namespace Projects%3B
     </ItemGroup>
   </Target>
 
+  <Target Name="EmbedAppHostIntermediateOutputPath" BeforeTargets="GetAssemblyAttributes" Condition=" '$(IsAspireHost)' == 'true' ">
+    <ItemGroup>
+      <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+        <_Parameter1>apphostprojectbaseintermediateoutputpath</_Parameter1>
+        <_Parameter2>$(BaseIntermediateOutputPath)</_Parameter2>
+      </AssemblyAttribute>
+    </ItemGroup>
+  </Target>
+
   <PropertyGroup>
     <AspirePublisher Condition="'$(AspirePublisher)' == ''">manifest</AspirePublisher>
     <AspireManifestPublishOutputPath Condition="'$(AspireManifestPublishOutputPath)' == ''">$(_AspireIntermediatePath)</AspireManifestPublishOutputPath>

src/Aspire.Hosting/AspireStore.cs

@@ -0,0 +1,234 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection;
+using System.Security.Cryptography;
+
+namespace Aspire.Hosting;
+
+/// <summary>
+/// Represents a store for managing files in the Aspire hosting environment that can be reused across runs.
+/// </summary>
+/// <remarks>
+/// The store is created in the ./obj folder of the Application Host.
+/// If the ASPIRE_STORE_DIR environment variable is set this will be used instead.
+///
+/// The store is specific to a <see cref="IDistributedApplicationBuilder"/> instance such that each application can't
+/// conflict with others. A <em>.aspire</em> prefix is also used to ensure that the folder can be delete without impacting
+/// unrelated files.
+/// </remarks>
+public class AspireStore
+{
+    internal const string AspireStorePathKeyName = "Aspire:Store:Path";
+
+    private readonly string _basePath;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AspireStore"/> class with the specified base path.
+    /// </summary>
+    /// <param name="basePath">The base path for the store.</param>
+    private AspireStore(string basePath)
+    {
+        ArgumentNullException.ThrowIfNull(basePath);
+
+        _basePath = basePath;
+        EnsureDirectory();
+    }
+
+    /// <summary>
+    /// Gets the base path of this store.
+    /// </summary>
+    public string BasePath => _basePath;
+
+    /// <summary>
+    /// Creates a new instance of <see cref="AspireStore"/> using the provided <paramref name="builder"/>.
+    /// </summary>
+    /// <param name="builder">The <see cref="IDistributedApplicationBuilder"/>.</param>
+    /// <returns>A new instance of <see cref="AspireStore"/>.</returns>
+    public static AspireStore Create(IDistributedApplicationBuilder builder)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        var assemblyMetadata = builder.AppHostAssembly?.GetCustomAttributes<AssemblyMetadataAttribute>();
+        var objDir = GetMetadataValue(assemblyMetadata, "AppHostProjectBaseIntermediateOutputPath");
+
+        var fallbackDir = builder.Configuration[AspireStorePathKeyName];
+
+        var root = fallbackDir ?? objDir;
+
+        if (string.IsNullOrEmpty(root))
+        {
+            throw new InvalidOperationException($"Could not determine an appropriate location for storing user secrets. Set the {AspireStorePathKeyName} setting to a folder where the App Host content should be stored.");
+        }
+
+        var directoryPath = Path.Combine(root, ".aspire");
+
+        // The /obj directory doesn't need to be prefixed with the app host name.
+        if (root != objDir)
+        {
+            directoryPath = Path.Combine(directoryPath, GetAppHostSpecificPrefix(builder));
+        }
+
+        return new AspireStore(directoryPath);
+    }
+
+    /// <summary>
+    /// Gets the metadata value for the specified key from the assembly metadata.
+    /// </summary>
+    /// <param name="assemblyMetadata">The assembly metadata.</param>
+    /// <param name="key">The key to look for.</param>
+    /// <returns>The metadata value if found; otherwise, null.</returns>
+    private static string? GetMetadataValue(IEnumerable<AssemblyMetadataAttribute>? assemblyMetadata, string key) =>
+        assemblyMetadata?.FirstOrDefault(a => string.Equals(a.Key, key, StringComparison.OrdinalIgnoreCase))?.Value;
+
+    /// <summary>
+    /// Gets the application host specific prefix based on the builder's environment.
+    /// </summary>
+    /// <param name="builder">The <see cref="IDistributedApplicationBuilder"/>.</param>
+    /// <returns>The application host specific prefix.</returns>
+    private static string GetAppHostSpecificPrefix(IDistributedApplicationBuilder builder)
+    {
+        var appName = Sanitize(builder.Environment.ApplicationName).ToLowerInvariant();
+        var appNameHash = builder.Configuration["AppHost:Sha256"]![..10].ToLowerInvariant();
+        return $"{appName}.{appNameHash}";
+    }
+
+    /// <summary>
+    /// Gets a deterministic file path that is a copy of the <paramref name="sourceFilename"/>.
+    /// The resulting file name will depend on the content of the file.
+    /// </summary>
+    /// <param name="filename">A file name to base the result on.</param>
+    /// <param name="sourceFilename">An existing file.</param>
+    /// <returns>A deterministic file path with the same content as <paramref name="sourceFilename"/>.</returns>
+    /// <exception cref="FileNotFoundException">Thrown when the source file does not exist.</exception>
+    public string GetFileNameWithContent(string filename, string sourceFilename)
+    {
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(filename);
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(sourceFilename);
+
+        if (!File.Exists(sourceFilename))
+        {
+            throw new FileNotFoundException("The source file '{0}' does not exist.", sourceFilename);
+        }
+
+        EnsureDirectory();
+
+        // Strip any folder information from the filename.
+        filename = Path.GetFileName(filename);
+
+        // Delete existing file versions with the same name.
+        var allFiles = Directory.EnumerateFiles(_basePath, filename + ".*");
+
+        foreach (var file in allFiles)
+        {
+            try
+            {
+                File.Delete(file);
+            }
+            catch
+            {
+            }
+        }
+
+        var hashStream = File.OpenRead(sourceFilename);
+
+        // Compute the hash of the content.
+        var hash = SHA256.HashData(hashStream);
+
+        hashStream.Dispose();
+
+        var name = Path.GetFileNameWithoutExtension(filename);
+        var ext = Path.GetExtension(filename);
+        var finalFilePath = Path.Combine(_basePath, $"{name}.{Convert.ToHexString(hash)[..12].ToLowerInvariant()}{ext}".ToLowerInvariant());
+
+        if (!File.Exists(finalFilePath))
+        {
+            File.Copy(sourceFilename, finalFilePath, overwrite: true);
+        }
+
+        return finalFilePath;
+    }
+
+    /// <summary>
+    /// Gets a deterministic file path that is a copy of the content from the provided stream.
+    /// The resulting file name will depend on the content of the stream.
+    /// </summary>
+    /// <param name="filename">A file name to base the result on.</param>
+    /// <param name="contentStream">A stream containing the content.</param>
+    /// <returns>A deterministic file path with the same content as the provided stream.</returns>
+    public string GetFileNameWithContent(string filename, Stream contentStream)
+    {
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(filename);
+        ArgumentNullException.ThrowIfNull(contentStream);
+
+        // Create a temporary file to write the content to.
+        var tempFileName = Path.GetTempFileName();
+
+        // Write the content to the temporary file.
+        using (var fileStream = File.OpenWrite(tempFileName))
+        {
+            contentStream.CopyTo(fileStream);
+        }
+
+        var finalFilePath = GetFileNameWithContent(filename, tempFileName);
+
+        try
+        {
+            File.Delete(tempFileName);
+        }
+        catch
+        {
+        }
+
+        return finalFilePath;
+    }
+
+    /// <summary>
+    /// Creates an absolute file name for the provided <paramref name="filename"/> in the store.
+    /// </summary>
+    /// <param name="filename">The file name to use in the store.</param>
+    /// <returns>The absolute file name in the store.</returns>
+    public string GetFileName(string filename)
+    {
+        EnsureDirectory();
+
+        // Strip any folder information from the filename.
+        filename = Path.GetFileName(filename);
+
+        return Path.Combine(_basePath, filename);
+    }
+
+    /// <summary>
+    /// Removes any unwanted characters from the <paramref name="filename"/>.
+    /// </summary>
+    /// <param name="filename">The filename to sanitize.</param>
+    /// <returns>The sanitized filename.</returns>
+    internal static string Sanitize(string filename)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(filename);
+
+        return string.Create(filename.Length, filename, static (s, name) =>
+        {
+            // First char must be a letter of digit
+            s[0] = char.IsAsciiLetterOrDigit(name[0]) ? name[0] : '_';
+
+            for (var i = 1; i < name.Length; i++)
+            {
+                var c = name[i];
+
+                s[i] = char.IsAsciiLetterOrDigit(c) || c == '.' ? c : '_';
+            }
+        });
+    }
+
+    /// <summary>
+    /// Ensures that the directory for the store exists.
+    /// </summary>
+    private void EnsureDirectory()
+    {
+        if (!string.IsNullOrEmpty(_basePath) && !Directory.Exists(_basePath))
+        {
+            Directory.CreateDirectory(_basePath);
+        }
+    }
+}

src/Shared/SecretsStore.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Json.Nodes;
 using Microsoft.Extensions.Configuration;

tests/Aspire.Hosting.Azure.Tests/AzureServiceBusExtensionsTests.cs

@@ -188,6 +188,7 @@ public async Task VerifyWaitForOnServiceBusEmulatorBlocksDependentResources()
     {
         var cts = new CancellationTokenSource(TimeSpan.FromMinutes(10));
         using var builder = TestDistributedApplicationBuilder.Create(output);
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         var healthCheckTcs = new TaskCompletionSource<HealthCheckResult>();
         builder.Services.AddHealthChecks().AddAsyncCheck("blocking_check", () =>
@@ -231,6 +232,8 @@ public async Task VerifyAzureServiceBusEmulatorResource()
         var cts = new CancellationTokenSource(TimeSpan.FromMinutes(10));
 
         using var builder = TestDistributedApplicationBuilder.Create().WithTestAndResourceLogging(output);
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
+
         var serviceBus = builder.AddAzureServiceBus("servicebusns")
             .RunAsEmulator()
             .WithQueue("queue123");
@@ -267,6 +270,8 @@ public async Task VerifyAzureServiceBusEmulatorResource()
     public void AddAzureServiceBusWithEmulatorGetsExpectedPort(int? port = null)
     {
         using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
+
         var serviceBus = builder.AddAzureServiceBus("sb").RunAsEmulator(configureContainer: builder =>
         {
             builder.WithHostPort(port);
@@ -286,6 +291,7 @@ public void AddAzureServiceBusWithEmulatorGetsExpectedImageTag(string? imageTag)
     {
         using var builder = TestDistributedApplicationBuilder.Create();
         var serviceBus = builder.AddAzureServiceBus("sb");
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         serviceBus.RunAsEmulator(container =>
         {
@@ -415,6 +421,7 @@ public async Task AzureServiceBusEmulatorResourceInitializesProvisioningModel()
     public async Task AzureServiceBusEmulatorResourceGeneratesConfigJson()
     {
         using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         var serviceBus = builder.AddAzureServiceBus("servicebusns")
             .RunAsEmulator()
@@ -551,6 +558,7 @@ public async Task AzureServiceBusEmulatorResourceGeneratesConfigJson()
     public async Task AzureServiceBusEmulatorResourceGeneratesConfigJsonOnlyChangedProperties()
     {
         using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         var serviceBus = builder.AddAzureServiceBus("servicebusns")
             .RunAsEmulator()
@@ -599,6 +607,7 @@ public async Task AzureServiceBusEmulatorResourceGeneratesConfigJsonOnlyChangedP
     public async Task AzureServiceBusEmulatorResourceGeneratesConfigJsonWithCustomizations()
     {
         using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         var serviceBus = builder.AddAzureServiceBus("servicebusns")
             .RunAsEmulator(configure => configure.ConfigureEmulator(document =>
@@ -639,6 +648,7 @@ public async Task AzureServiceBusEmulatorResourceGeneratesConfigJsonWithCustomiz
     public async Task AzureServiceBusEmulator_WithConfigurationFile()
     {
         using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
 
         var configJsonPath = Path.GetTempFileName();
 
@@ -692,4 +702,39 @@ public async Task AzureServiceBusEmulator_WithConfigurationFile()
         {
         }
     }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void AddAzureServiceBusWithEmulator_SetsSqlLifetime(bool isPersistent)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
+        var lifetime = isPersistent ? ContainerLifetime.Persistent : ContainerLifetime.Session;
+
+        var serviceBus = builder.AddAzureServiceBus("sb").RunAsEmulator(configureContainer: builder =>
+        {
+            builder.WithLifetime(lifetime);
+        });
+
+        var sql = builder.Resources.FirstOrDefault(x => x.Name == "sb-sqledge");
+
+        Assert.NotNull(sql);
+
+        serviceBus.Resource.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var sbLifetimeAnnotation);
+        sql.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var sqlLifetimeAnnotation);
+
+        Assert.Equal(lifetime, sbLifetimeAnnotation?.Lifetime);
+        Assert.Equal(lifetime, sqlLifetimeAnnotation?.Lifetime);
+    }
+
+    [Fact]
+    public void RunAsEmulator_CalledTwice_Throws()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        builder.Configuration["Aspire:Store:Path"] = Path.GetTempPath();
+        var serviceBus = builder.AddAzureServiceBus("sb").RunAsEmulator();
+
+        Assert.Throws<InvalidOperationException>(() => serviceBus.RunAsEmulator());
+    }
 }