Fix PostgreSQL v18+ data volume path (#14202)

PostgreSQL 18+ changed the default data directory from /var/lib/postgresql/data
to /var/lib/postgresql. This commit updates WithDataVolume and WithDataBindMount
to automatically detect the PostgreSQL version from the container image tag and
use the appropriate data directory path.

- Added GetPostgresDataDirectoryPath helper method
- Added TryParsePostgresMajorVersion helper method
- Updated WithDataVolume to use version-aware path
- Updated WithDataBindMount to use version-aware path
- Added comprehensive unit tests for version parsing and path selection

Fixes #13792

Author: kieronlanning

src/Aspire.Hosting.PostgreSQL/PostgresBuilderExtensions.cs

@@ -422,12 +422,26 @@ private static void SetPgAdminEnvironmentVariables(EnvironmentCallbackContext co
     /// <param name="name">The name of the volume. Defaults to an auto-generated name based on the application and resource names.</param>
     /// <param name="isReadOnly">A flag that indicates if this is a read-only volume.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// The data directory location varies by PostgreSQL version:
+    /// </para>
+    /// <list type="bullet">
+    ///   <item><description>PostgreSQL 17 and earlier: <c>/var/lib/postgresql/data</c></description></item>
+    ///   <item><description>PostgreSQL 18 and later: <c>/var/lib/postgresql</c></description></item>
+    /// </list>
+    /// <para>
+    /// This method automatically selects the correct path based on the configured container image tag.
+    /// </para>
+    /// </remarks>
     public static IResourceBuilder<PostgresServerResource> WithDataVolume(this IResourceBuilder<PostgresServerResource> builder, string? name = null, bool isReadOnly = false)
     {
         ArgumentNullException.ThrowIfNull(builder);
 
+        var dataPath = GetPostgresDataDirectoryPath(builder);
+
         return builder.WithVolume(name ?? VolumeNameGenerator.Generate(builder, "data"),
-            "/var/lib/postgresql/data", isReadOnly);
+            dataPath, isReadOnly);
     }
 
     /// <summary>
@@ -437,12 +451,26 @@ public static IResourceBuilder<PostgresServerResource> WithDataVolume(this IReso
     /// <param name="source">The source directory on the host to mount into the container.</param>
     /// <param name="isReadOnly">A flag that indicates if this is a read-only mount.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// The data directory location varies by PostgreSQL version:
+    /// </para>
+    /// <list type="bullet">
+    ///   <item><description>PostgreSQL 17 and earlier: <c>/var/lib/postgresql/data</c></description></item>
+    ///   <item><description>PostgreSQL 18 and later: <c>/var/lib/postgresql</c></description></item>
+    /// </list>
+    /// <para>
+    /// This method automatically selects the correct path based on the configured container image tag.
+    /// </para>
+    /// </remarks>
     public static IResourceBuilder<PostgresServerResource> WithDataBindMount(this IResourceBuilder<PostgresServerResource> builder, string source, bool isReadOnly = false)
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentException.ThrowIfNullOrEmpty(source);
 
-        return builder.WithBindMount(source, "/var/lib/postgresql/data", isReadOnly);
+        var dataPath = GetPostgresDataDirectoryPath(builder);
+
+        return builder.WithBindMount(source, dataPath, isReadOnly);
     }
 
     /// <summary>
@@ -620,6 +648,51 @@ private static async Task<string> WritePgAdminServerJson(IEnumerable<PostgresSer
         return Encoding.UTF8.GetString(stream.ToArray());
     }
 
+    /// <summary>
+    /// Gets the appropriate PostgreSQL data directory path based on the image version.
+    /// </summary>
+    /// <remarks>
+    /// PostgreSQL 18+ changed the data directory from /var/lib/postgresql/data to /var/lib/postgresql.
+    /// See https://github.com/docker-library/postgres/pull/1259 for more information.
+    /// </remarks>
+    internal static string GetPostgresDataDirectoryPath(IResourceBuilder<PostgresServerResource> builder)
+    {
+        if (builder.Resource.Annotations.OfType<ContainerImageAnnotation>().LastOrDefault() is { } imageAnnotation)
+        {
+            var tag = imageAnnotation.Tag ?? PostgresContainerImageTags.Tag;
+            if (TryParsePostgresMajorVersion(tag, out var majorVersion) && majorVersion >= 18)
+            {
+                return "/var/lib/postgresql";
+            }
+        }
+
+        return "/var/lib/postgresql/data";
+    }
+
+    /// <summary>
+    /// Attempts to parse the PostgreSQL major version from an image tag.
+    /// </summary>
+    /// <param name="tag">The image tag (e.g., "17.6", "18.1", "18-alpine", "latest").</param>
+    /// <param name="majorVersion">The parsed major version number, if successful.</param>
+    /// <returns><see langword="true"/> if the major version was successfully parsed; otherwise, <see langword="false"/>.</returns>
+    internal static bool TryParsePostgresMajorVersion(string tag, out int majorVersion)
+    {
+        majorVersion = 0;
+
+        if (string.IsNullOrWhiteSpace(tag))
+        {
+            return false;
+        }
+
+        // Handle tags like "18.1-alpine", "17.6-bookworm", etc.
+        var versionPart = tag.Split('-')[0];
+
+        // Handle tags like "18.1", "17", etc.
+        var parts = versionPart.Split('.');
+
+        return parts.Length > 0 && int.TryParse(parts[0], out majorVersion) && majorVersion > 0;
+    }
+
     private static async Task CreateDatabaseAsync(NpgsqlConnection npgsqlConnection, PostgresDatabaseResource npgsqlDatabase, IServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
         var scriptAnnotation = npgsqlDatabase.Annotations.OfType<PostgresCreateDatabaseScriptAnnotation>().LastOrDefault();

tests/Aspire.Hosting.PostgreSQL.Tests/AddPostgresTests.cs

@@ -706,4 +706,169 @@ public async Task PostgresEnvironmentCallbackIsIdempotent()
             Assert.Equal(kvp.Value, config2[kvp.Key]);
         });
     }
+
+    [Theory]
+    [InlineData("17.6", 17)]
+    [InlineData("18.1", 18)]
+    [InlineData("18", 18)]
+    [InlineData("18-alpine", 18)]
+    [InlineData("17.6-bookworm", 17)]
+    [InlineData("16.0", 16)]
+    [InlineData("9.6", 9)]
+    public void TryParsePostgresMajorVersionReturnsTrueForValidTags(string tag, int expectedMajorVersion)
+    {
+        var result = PostgresBuilderExtensions.TryParsePostgresMajorVersion(tag, out var majorVersion);
+
+        Assert.True(result);
+        Assert.Equal(expectedMajorVersion, majorVersion);
+    }
+
+    [Theory]
+    [InlineData("latest")]
+    [InlineData("alpine")]
+    [InlineData("")]
+    [InlineData("  ")]
+    [InlineData("abc")]
+    public void TryParsePostgresMajorVersionReturnsFalseForInvalidTags(string tag)
+    {
+        var result = PostgresBuilderExtensions.TryParsePostgresMajorVersion(tag, out var majorVersion);
+
+        Assert.False(result);
+        Assert.Equal(0, majorVersion);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void WithDataVolumeUsesLegacyPathForPostgres17(bool? isReadOnly)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres");
+
+        // Default image is v17.x, so should use legacy path
+        if (isReadOnly.HasValue)
+        {
+            postgres.WithDataVolume(isReadOnly: isReadOnly.Value);
+        }
+        else
+        {
+            postgres.WithDataVolume();
+        }
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        Assert.Equal($"{builder.GetVolumePrefix()}-myPostgres-data", volumeAnnotation.Source);
+        Assert.Equal("/var/lib/postgresql/data", volumeAnnotation.Target);
+        Assert.Equal(ContainerMountType.Volume, volumeAnnotation.Type);
+        Assert.Equal(isReadOnly ?? false, volumeAnnotation.IsReadOnly);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void WithDataVolumeUsesNewPathForPostgres18(bool? isReadOnly)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres")
+            .WithImage("postgres", "18.1");
+
+        if (isReadOnly.HasValue)
+        {
+            postgres.WithDataVolume(isReadOnly: isReadOnly.Value);
+        }
+        else
+        {
+            postgres.WithDataVolume();
+        }
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        Assert.Equal($"{builder.GetVolumePrefix()}-myPostgres-data", volumeAnnotation.Source);
+        Assert.Equal("/var/lib/postgresql", volumeAnnotation.Target);
+        Assert.Equal(ContainerMountType.Volume, volumeAnnotation.Type);
+        Assert.Equal(isReadOnly ?? false, volumeAnnotation.IsReadOnly);
+    }
+
+    [Fact]
+    public void WithDataVolumeUsesNewPathForPostgres18Alpine()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres")
+            .WithImage("postgres", "18-alpine")
+            .WithDataVolume();
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        Assert.Equal("/var/lib/postgresql", volumeAnnotation.Target);
+    }
+
+    [Fact]
+    public void WithDataVolumeUsesLegacyPathForUnparsableTag()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres")
+            .WithImage("postgres", "latest")
+            .WithDataVolume();
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        // When tag can't be parsed, fall back to legacy path for safety
+        Assert.Equal("/var/lib/postgresql/data", volumeAnnotation.Target);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void WithDataBindMountUsesLegacyPathForPostgres17(bool? isReadOnly)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres");
+
+        // Default image is v17.x, so should use legacy path
+        if (isReadOnly.HasValue)
+        {
+            postgres.WithDataBindMount("mydata", isReadOnly: isReadOnly.Value);
+        }
+        else
+        {
+            postgres.WithDataBindMount("mydata");
+        }
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source);
+        Assert.Equal("/var/lib/postgresql/data", volumeAnnotation.Target);
+        Assert.Equal(ContainerMountType.BindMount, volumeAnnotation.Type);
+        Assert.Equal(isReadOnly ?? false, volumeAnnotation.IsReadOnly);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void WithDataBindMountUsesNewPathForPostgres18(bool? isReadOnly)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+        var postgres = builder.AddPostgres("myPostgres")
+            .WithImage("postgres", "18.1");
+
+        if (isReadOnly.HasValue)
+        {
+            postgres.WithDataBindMount("mydata", isReadOnly: isReadOnly.Value);
+        }
+        else
+        {
+            postgres.WithDataBindMount("mydata");
+        }
+
+        var volumeAnnotation = postgres.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
+
+        Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source);
+        Assert.Equal("/var/lib/postgresql", volumeAnnotation.Target);
+        Assert.Equal(ContainerMountType.BindMount, volumeAnnotation.Type);
+        Assert.Equal(isReadOnly ?? false, volumeAnnotation.IsReadOnly);
+    }
 }