container xxxxx is not running in GitHub Actions only

[SamLevene-CAL]

Hi all, I've tried everything I can possibly think of to resolve it, but now I'm out of ideas. I need help explaining why; when I try to run a Testcontainer in my GitHub Actions runner; I get the following error:

OneTimeSetUp: Docker.DotNet.DockerApiException : Docker API responded with status code=Conflict, response={"message":"container xxxxx is not running"}

This works locally for my Playwright and Reqnroll UI test framework, but whenever I try to run it in my GitHub Actions CI/CD pipeline, I get that message. I've tried following countless thoughts from other help sites like StackOverflow and blogs, but nothing's helped. So I thought I'd come to the experts to ask.

The error specifically mentions a line in my code that tries to start a MailDev Test container (await _mailDevContainer.StartAsync();)

Here's my implementation:

using System;
using System.Net;
using System.Net.Http;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Tests.Configuration; //(LOCAL REFERENCE)
using Tests.Helpers; //(LOCAL REFERENCE)
using Tests.Services; //(LOCAL REFERENCE)
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Containers;
using Microsoft.Extensions.Configuration;
using Reqnroll;
using Reqnroll.BoDi;

 [Binding]
 public class TestRunHooks
 {
        private static IContainer _mailDevContainer;

        [BeforeTestRun]
        public static async Task BeforeTestRun(IObjectContainer objectContainer)
        {
            var configuration = new ConfigurationBuilder()
               .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
               .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
               .AddEnvironmentVariables() // Load environment variables
               .AddUserSecrets<IdentityProviderConfiguration>()
               .Build();
            objectContainer?.RegisterInstanceAs(configuration);

            var baseLoggingDirectory = environmentConfiguration!.AreTestsExecutedOnRemoteServer!
                ? LoggingConfiguration.GetFileShareMainDirectory()
                : LoggingConfiguration.GetSharedDriveMainDirectory();

            var logger = new Logger(baseLoggingDirectory);
            objectContainer?.RegisterInstanceAs(logger);

            var smtpMailDevConfiguration = configuration.GetSection("SmtpMailDev").Get<SmtpMailDevConfiguration>();
            objectContainer?.RegisterInstanceAs(smtpMailDevConfiguration);

            var playwrightConfiguration = configuration.GetSection("PlaywrightConfiguration").Get<PlaywrightConfiguration>();
            playwrightConfiguration.BrowserType = GetEnvironmentVariableOrDefault("PLAYWRIGHT_BROWSER_TYPE", playwrightConfiguration.BrowserType!);

            objectContainer?.RegisterInstanceAs(playwrightConfiguration);

            var httpClient = new HttpClient(GetTrustingHandler())
            {
                BaseAddress = new Uri(environmentConfiguration!.IdentityProviderBaseUrl!)
            };
            objectContainer?.RegisterInstanceAs(httpClient, dispose: true);

            var loggingConfiguration = configuration.GetSection("LoggingConfiguration").Get<LoggingConfiguration>();
            objectContainer?.RegisterInstanceAs(loggingConfiguration ?? new LoggingConfiguration());

            var authorisationService = new AuthorisationService(httpClient, identityProviderConfiguration, logger);
            objectContainer?.RegisterInstanceAs<IAuthorisationService>(authorisationService);

            objectContainer?.RegisterInstanceAs<IApiResourceService>(new ApiResourceService(httpClient));

            objectContainer?.RegisterInstanceAs(new UserService(httpClient, authorisationService));

            objectContainer?.RegisterInstanceAs(new TwoFactorService(objectContainer.Resolve<Feature>(),identityProviderConfiguration));

            var mailDevContainerBuilder = new ContainerBuilder()
                .WithImage("maildev/maildev:latest")
                .WithPortBinding(1080, 1080)
                .WithPortBinding(1025, 1025)
                .WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(1080));

            if (smtpMailDevConfiguration.ReuseMailDevTestContainer)
            {
                mailDevContainerBuilder = mailDevContainerBuilder
                    .WithReuse(true)
                    .WithLabel("reuse-id", "idp_maildev_test")
                    .WithCleanUp(false);
            }

            _mailDevContainer = mailDevContainerBuilder.Build();
            await _mailDevContainer.StartAsync();

            objectContainer?.RegisterInstanceAs(_mailDevContainer);
        }

        [AfterTestRun]
        public static async Task AfterTestRun(ObjectContainer objectContainer)
        {
            var smtpMailDevConfiguration = objectContainer.Resolve<SmtpMailDevConfiguration>();
            if (!smtpMailDevConfiguration.ReuseMailDevTestContainer)
            {
                await _mailDevContainer.StopAsync();
                await _mailDevContainer.DisposeAsync();
            }
        }
        
        private static string GetEnvironmentVariableOrDefault(string variableName, string defaultValue)
        {
            var value = Environment.GetEnvironmentVariable(variableName);
            return !string.IsNullOrEmpty(value) ? value : defaultValue;
        }
        
        private static bool GetEnvironmentVariableOrDefault(string variableName, bool defaultValue)
        {
            var value = Environment.GetEnvironmentVariable(variableName);
            return bool.TryParse(value, out var result) ? result : defaultValue;
        }
        
        private static HttpClientHandler GetTrustingHandler()
        {
            var trustingHandler = new HttpClientHandler();
            var proxyServer = Environment.GetEnvironmentVariable("http_proxy");
        
            if (!string.IsNullOrEmpty(proxyServer))
            {
                var bypassList = Environment.GetEnvironmentVariable("no_proxy")?.Replace("*", ".*").Split(',');
                var webProxy = new WebProxy(new Uri(proxyServer), true, bypassList);
                trustingHandler.Proxy = webProxy;
                trustingHandler.UseProxy = false;
            }
        
            trustingHandler.ServerCertificateCustomValidationCallback = CertValidationCallback!;
            return trustingHandler;
        }
        
        private static bool CertValidationCallback(HttpRequestMessage requestMessage, X509Certificate2 cert, X509Chain chain, SslPolicyErrors policyErrors)
        {
            return policyErrors == SslPolicyErrors.None
                   || (policyErrors == SslPolicyErrors.RemoteCertificateNameMismatch
                       && !string.IsNullOrEmpty(cert!.Subject!)
                       && (cert!.Subject!.Contains("calastone.com") || cert!.Subject!.Contains("calastonetest.com")));
        }
}

[HofmeisterAn]

OneTimeSetUp: Docker.DotNet.DockerApiException : Docker API responded with status code=Conflict, response={"message":"container xxxxx is not running"}

It looks like the container is crashing on startup. To help troubleshoot, please share the container logs and the output of docker inspect <container_id>.

But before doing that, make sure you've followed the documented best practices.

1. Avoid using static ports. Instead, let Docker assign random host ports. There's no way to guarantee the ports you pick aren't already in use by another process.
2. Don't rely on checking if a port is open to detect readiness. A port might be open before the actual service is fully up and running. Use a more reliable approach to check if the service is ready (e.g. logs or a health API).

[SamLevene-CAL]

Hi Hofmeister. I'll try that and let you know, but first in answer to your points:

1. I can't. I'm doing this for my company; which only allows certain ports whitelisted through the company firewall. 1080/1025 are the whitelisted SMTP ports and so I can't just ushort a random port and hope; because chances are, it's not whitelisted.
2. Let me look into that

[SamLevene-CAL]

@HofmeisterAn - The command doesn't work as the id for container_id is randomly generated and I'm not able to query it

[HofmeisterAn]

Is 1. really the case? It's a local connection (from the host to the container). Does the firewall actually block local connections? Also, is your GitHub runner a private runner?

As for docker inspect <container_id> and docker logs <container_id>, there are plenty of ways to debug the container. You can disable cleanup and export the recently created containers, or just use a static container name to make debugging easier.