Part 18: Talking to Podman Compose — The Diff That Matters📋

[BinaryWrapper("podman-compose", HelpCommand = "--help")]
public partial class PodmanComposeClient : IPodmanComposeClient
{
    [Command("up")]
    public partial Task<Result<PodmanComposeUpOutput>> UpAsync(
        [Flag("-f", IsList = true)] IReadOnlyList<string> files,
        [Flag("-p")] string projectName,
        [Flag("-d", IsBoolean = true)] bool detach = true,
        // NB: --profile is supported by podman-compose ≥ 1.0.6
        [Flag("--profile", IsList = true)] IReadOnlyList<string>? profiles = null,
        CancellationToken ct = default);

    [Command("down")]
    public partial Task<Result<PodmanComposeDownOutput>> DownAsync(
        [Flag("-f", IsList = true)] IReadOnlyList<string> files,
        [Flag("-p")] string projectName,
        [Flag("-v", IsBoolean = true)] bool removeVolumes = false,
        CancellationToken ct = default);

    [Command("ps")]
    public partial Task<Result<PodmanComposePsOutput>> PsAsync(
        [Flag("-f", IsList = true)] IReadOnlyList<string> files,
        [Flag("-p")] string projectName,
        CancellationToken ct = default);

    [Command("config")]
    public partial Task<Result<PodmanComposeConfigOutput>> ConfigAsync(
        [Flag("-f", IsList = true)] IReadOnlyList<string> files,
        CancellationToken ct = default);

    [Command("logs")]
    public partial Task<Result<PodmanComposeLogsOutput>> LogsAsync(
        [Flag("-f", IsList = true)] IReadOnlyList<string> files,
        [Flag("-p")] string projectName,
        CancellationToken ct = default);
}

[Injectable(ServiceLifetime.Singleton)]
public sealed class PodmanComposeVersionGuard
{
    private readonly PodmanComposeClient _compose;
    private readonly Version _minimum = new(1, 0, 6);

    public async Task<Result> CheckAsync(CancellationToken ct)
    {
        var versionResult = await _compose.RawAsync(new[] { "--version" }, ct);
        if (versionResult.IsFailure) return versionResult.Map();

        var match = Regex.Match(versionResult.Value, @"podman-compose version (\d+\.\d+\.\d+)");
        if (!match.Success) return Result.Failure("could not parse podman-compose version");

        var version = Version.Parse(match.Groups[1].Value);
        if (version < _minimum)
            return Result.Failure(
                $"podman-compose {version} is too old; HomeLab requires ≥ {_minimum} for `condition: service_healthy`");

        return Result.Success();
    }
}

[Injectable(ServiceLifetime.Singleton)]
public sealed class PodmanComposeAsDockerCompose : IDockerComposeClient
{
    private readonly PodmanComposeClient _inner;
    private readonly ILogger<PodmanComposeAsDockerCompose> _log;

    public ComposeVersion Version => ComposeVersion.V2; // closest equivalent

    public async Task<Result<ComposeUpOutput>> UpAsync(string composeFile, string projectName, bool detach, IReadOnlyList<string>? profiles, TimeSpan? timeout, CancellationToken ct)
    {
        if (timeout is not null)
            _log.LogWarning("podman-compose does not support --timeout; ignoring");

        var result = await _inner.UpAsync(new[] { composeFile }, projectName, detach, profiles, ct);
        return result.Map(o => new ComposeUpOutput(o.ContainersStarted));
    }

    public Task<Result<ComposePauseOutput>> PauseAsync(string composeFile, string projectName, CancellationToken ct)
        => Task.FromResult(Result.Failure<ComposePauseOutput>(
            "podman-compose does not support `pause` — use `podman pod pause` directly if you need this"));

    // ... etc
}

public sealed class PodmanComposeDivergenceTests
{
    [Fact]
    public async Task version_guard_fails_for_old_podman_compose()
    {
        var compose = new ScriptedPodmanComposeClient();
        compose.OnRaw(new[] { "--version" }, exitCode: 0, stdout: "podman-compose version 1.0.3");
        var guard = new PodmanComposeVersionGuard(compose);

        var result = await guard.CheckAsync(CancellationToken.None);

        result.IsFailure.Should().BeTrue();
        result.Errors.Should().Contain(e => e.Contains("1.0.3") && e.Contains("1.0.6"));
    }

    [Fact]
    public async Task version_guard_passes_for_new_podman_compose()
    {
        var compose = new ScriptedPodmanComposeClient();
        compose.OnRaw(new[] { "--version" }, exitCode: 0, stdout: "podman-compose version 1.2.0");
        var guard = new PodmanComposeVersionGuard(compose);

        var result = await guard.CheckAsync(CancellationToken.None);

        result.IsSuccess.Should().BeTrue();
    }

    [Fact]
    public async Task pause_returns_failure_with_clear_message()
    {
        var bridge = new PodmanComposeAsDockerCompose(new ScriptedPodmanComposeClient(), Mock.Of<ILogger<PodmanComposeAsDockerCompose>>());

        var result = await bridge.PauseAsync("compose.yaml", "test", CancellationToken.None);

        result.IsFailure.Should().BeTrue();
        result.Errors.Should().Contain(e => e.Contains("does not support `pause`"));
    }

    [Fact]
    public async Task version_field_stripped_from_emitted_compose_when_engine_is_podman()
    {
        var compose = new ComposeFile { Version = "3.8" };
        var contributor = new GitLabComposeContributor();
        contributor.Contribute(compose);

        var serializer = new ComposeSerializer(engine: "podman");
        var yaml = serializer.Serialize(compose);

        yaml.Should().NotContain("version:");
        yaml.Should().Contain("services:");
    }
}