Part 17: Talking to Podman — Rootless, Daemonless, Different📋

[BinaryWrapper("podman", HelpCommand = "--help", VersionCommand = "version --format json")]
public partial class PodmanClient : IPodmanClient
{
    [Command("ps")]
    public partial Task<Result<PodmanPsOutput>> PsAsync(
        [Flag("--all", Aliases = "-a")] bool all = false,
        [Flag("--filter")] IReadOnlyList<string>? filter = null,
        [Flag("--format")] string? format = null,
        CancellationToken ct = default);

    [Command("run")]
    public partial Task<Result<PodmanRunOutput>> RunAsync(
        [PositionalArgument(Position = 0)] string image,
        [PositionalArgument(Position = 1, IsList = true)] IReadOnlyList<string>? command = null,
        [Flag("--name")] string? name = null,
        [Flag("-d", IsBoolean = true)] bool detach = false,
        [Flag("--rm")] bool remove = false,
        [Flag("-e", IsKeyValue = true)] IReadOnlyDictionary<string, string>? env = null,
        [Flag("-v", IsList = true)] IReadOnlyList<string>? volume = null,
        [Flag("-p", IsList = true)] IReadOnlyList<string>? port = null,
        [Flag("--network")] string? network = null,
        [Flag("--restart")] string? restart = null,
        [Flag("--userns")] string? userns = null,           // ← podman-specific (rootless mapping)
        CancellationToken ct = default);

    [Command("system", SubCommand = "service")]
    public partial Task<Result<PodmanSystemServiceOutput>> SystemServiceAsync(
        [Flag("--time")] int? timeoutSeconds = 0,
        [PositionalArgument] string? socketUri = null,
        CancellationToken ct = default);

    [Command("generate", SubCommand = "systemd")]
    public partial Task<Result<PodmanGenerateSystemdOutput>> GenerateSystemdAsync(
        [PositionalArgument] string nameOrId,
        [Flag("--name")] bool useName = true,
        [Flag("--files")] bool toFiles = false,
        CancellationToken ct = default);

    // ... etc, ~80 commands
}

public interface IContainerEngine
{
    string Name { get; }
    bool IsRootless { get; }
    bool HasDaemon { get; }
    string SocketPath { get; }

    Task<Result> RunComposeAsync(string composeFile, string projectName, CancellationToken ct);
    Task<Result> StopComposeAsync(string projectName, CancellationToken ct);
    Task<Result<EngineHealthReport>> HealthCheckAsync(CancellationToken ct);
    Task<Result<string>> InspectAsync(string nameOrId, CancellationToken ct);
}

[Injectable(ServiceLifetime.Singleton)]
public sealed class DockerContainerEngine : IContainerEngine
{
    public string Name => "docker";
    public bool IsRootless => false;
    public bool HasDaemon => true;
    public string SocketPath => "/var/run/docker.sock";

    private readonly IDockerComposeClient _compose;
    private readonly IDockerClient _docker;
    public DockerContainerEngine(IDockerComposeClient compose, IDockerClient docker) { _compose = compose; _docker = docker; }

    public Task<Result> RunComposeAsync(string composeFile, string projectName, CancellationToken ct)
        => _compose.UpAsync(composeFile, projectName, detach: true, profiles: null, timeout: TimeSpan.FromMinutes(10), ct).Map();
    // ... etc
}

[Injectable(ServiceLifetime.Singleton)]
public sealed class PodmanContainerEngine : IContainerEngine
{
    public string Name => "podman";
    public bool IsRootless => true;
    public bool HasDaemon => false;
    public string SocketPath => $"/run/user/{UidResolver.CurrentUid()}/podman/podman.sock";

    private readonly IPodmanComposeClient _compose;
    private readonly IPodmanClient _podman;
    public PodmanContainerEngine(IPodmanComposeClient compose, IPodmanClient podman) { _compose = compose; _podman = podman; }

    public Task<Result> RunComposeAsync(string composeFile, string projectName, CancellationToken ct)
        => _compose.UpAsync(composeFile, projectName, ct).Map();
    // ... etc
}

services.AddSingleton<IContainerEngine>(sp =>
{
    var config = sp.GetRequiredService<IOptions<HomeLabConfig>>().Value;
    return config.Engine switch
    {
        "docker" => sp.GetRequiredService<DockerContainerEngine>(),
        "podman" => sp.GetRequiredService<PodmanContainerEngine>(),
        _ => throw new InvalidOperationException($"Unknown engine: {config.Engine}")
    };
});

public sealed class IContainerEngineParityTests
{
    public static IEnumerable<object[]> Engines() => new[]
    {
        new object[] { typeof(DockerContainerEngine) },
        new object[] { typeof(PodmanContainerEngine) }
    };

    [Theory, MemberData(nameof(Engines))]
    [Trait("category", "integration")]
    public async Task engine_can_run_a_simple_alpine_container(Type engineType)
    {
        var sp = TestServices.WithEngine(engineType);
        var engine = (IContainerEngine)sp.GetRequiredService(engineType);

        var result = await engine.RunComposeAsync(
            composeFile: "fixtures/alpine-echo.yaml",
            projectName: "parity-test",
            ct: CancellationToken.None);

        result.IsSuccess.Should().BeTrue($"engine {engine.Name} must run a basic container");
    }

    [Theory, MemberData(nameof(Engines))]
    public async Task engine_reports_its_capabilities_truthfully(Type engineType)
    {
        var engine = TestServices.WithEngine(engineType).GetRequiredService(engineType) as IContainerEngine;

        if (engine!.Name == "podman")
        {
            engine.IsRootless.Should().BeTrue();
            engine.HasDaemon.Should().BeFalse();
        }
        else
        {
            engine.IsRootless.Should().BeFalse();
            engine.HasDaemon.Should().BeTrue();
        }
    }
}