[#126] #IMPLEMENT 'assemblyName: DotNet.Testcontainers; function: Con…

…tainerRegistry' {Purge orphaned containers when the default application domain's parent process exits.}
testcontainers · Oct 4, 2019 · e5fd0cb · e5fd0cb
1 parent 3e21c90
commit e5fd0cb
Show file tree

Hide file tree

Showing 14 changed files with 101 additions and 27 deletions.
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
@@ -20,7 +20,8 @@ jobs:
   # Run Windows build and tests.
   - template: template/build.yml
     parameters:
-      name: Windows
+      name: BuildAndTestOnWindows
+      displayName: Windows
       vmImage: windows-2019
       dotNetCoreVersion: $(dotNetCoreVersion)
       cakeVersion: $(cakeVersion)
@@ -29,7 +30,8 @@ jobs:
   # Run Linux build and tests.
   - template: template/build.yml
     parameters:
-      name: Linux
+      name: BuildAndTestOnLinux
+      displayName: Linux
       vmImage: ubuntu-16.04
       dotNetCoreVersion: $(dotNetCoreVersion)
       cakeVersion: $(cakeVersion)
@@ -40,7 +42,8 @@ jobs:
   - ${{ if in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/develop') }}:
     - template: template/publish.yml
       parameters:
-        name: Linux
+        name: Release
+        displayName: Release
         vmImage: ubuntu-16.04
         dotNetCoreVersion: $(dotNetCoreVersion)
         cakeVersion: $(cakeVersion)
diff --git a/src/DotNet.Testcontainers.Tests/Unit/Linux/ImageFromDockerfileTest.cs b/src/DotNet.Testcontainers.Tests/Unit/Linux/ImageFromDockerfileTest.cs
@@ -4,7 +4,7 @@ namespace DotNet.Testcontainers.Tests.Unit.Linux
   using System.Collections.Generic;
   using System.IO;
   using System.Threading.Tasks;
-  using DotNet.Testcontainers.Core;
+  using DotNet.Testcontainers.Core.Archive;
   using DotNet.Testcontainers.Core.Builder;
   using ICSharpCode.SharpZipLib.Tar;
   using Xunit;

diff --git a/src/DotNet.Testcontainers/Clients/ContainerRegistry.cs b/src/DotNet.Testcontainers/Clients/ContainerRegistry.cs
@@ -0,0 +1,36 @@
+namespace DotNet.Testcontainers.Clients
+{
+  using System.Collections.Generic;
+  using System.Linq;
+
+  internal static class ContainerRegistry
+  {
+    private static readonly object RegisteredContainersPadLock = new object();
+
+    private static readonly IDictionary<string, bool> RegisteredContainers = new Dictionary<string, bool>();
+
+    public static IEnumerable<string> GetRegisteredContainers()
+    {
+      lock (RegisteredContainersPadLock)
+      {
+        return RegisteredContainers.Where(registeredContainer => true.Equals(registeredContainer.Value)).Select(registeredContainer => registeredContainer.Key);
+      }
+    }
+
+    public static void Register(string id, bool cleanUp = false)
+    {
+      lock (RegisteredContainersPadLock)
+      {
+        RegisteredContainers.Add(id, cleanUp);
+      }
+    }
+
+    public static void Unregister(string id)
+    {
+      lock (RegisteredContainersPadLock)
+      {
+        RegisteredContainers.Remove(id);
+      }
+    }
+  }
+}
diff --git a/src/DotNet.Testcontainers/Clients/MetaDataClientContainers.cs b/src/DotNet.Testcontainers/Clients/MetaDataClientContainers.cs
@@ -8,13 +8,13 @@ namespace DotNet.Testcontainers.Clients
 
   internal sealed class MetaDataClientContainers : DockerMetaDataClient<ContainerListResponse>
   {
-    private static readonly Lazy<MetaDataClientContainers> MetaDataClient = new Lazy<MetaDataClientContainers>(() => new MetaDataClientContainers());
+    private static readonly Lazy<MetaDataClientContainers> MetaDataClientLazy = new Lazy<MetaDataClientContainers>(() => new MetaDataClientContainers());
 
     private MetaDataClientContainers()
     {
     }
 
-    internal static MetaDataClientContainers Instance { get; } = MetaDataClient.Value;
+    internal static MetaDataClientContainers Instance { get; } = MetaDataClientLazy.Value;
 
     internal override async Task<IReadOnlyCollection<ContainerListResponse>> GetAllAsync()
     {

diff --git a/src/DotNet.Testcontainers/Clients/MetaDataClientImages.cs b/src/DotNet.Testcontainers/Clients/MetaDataClientImages.cs
@@ -8,13 +8,13 @@ namespace DotNet.Testcontainers.Clients
 
   internal sealed class MetaDataClientImages : DockerMetaDataClient<ImagesListResponse>
   {
-    private static readonly Lazy<MetaDataClientImages> MetaDataClient = new Lazy<MetaDataClientImages>(() => new MetaDataClientImages());
+    private static readonly Lazy<MetaDataClientImages> MetaDataClientLazy = new Lazy<MetaDataClientImages>(() => new MetaDataClientImages());
 
     private MetaDataClientImages()
     {
     }
 
-    internal static MetaDataClientImages Instance { get; } = MetaDataClient.Value;
+    internal static MetaDataClientImages Instance { get; } = MetaDataClientLazy.Value;
 
     internal override async Task<IReadOnlyCollection<ImagesListResponse>> GetAllAsync()
     {

diff --git a/src/DotNet.Testcontainers/Clients/MetaDataClientSystem.cs b/src/DotNet.Testcontainers/Clients/MetaDataClientSystem.cs
@@ -4,13 +4,13 @@ namespace DotNet.Testcontainers.Clients
 
   internal sealed class MetaDataClientSystem : DockerApiClient
   {
-    private static readonly Lazy<MetaDataClientSystem> MetaDataClient = new Lazy<MetaDataClientSystem>(() => new MetaDataClientSystem());
+    private static readonly Lazy<MetaDataClientSystem> MetaDataClientLazy = new Lazy<MetaDataClientSystem>(() => new MetaDataClientSystem());
 
     private MetaDataClientSystem()
     {
     }
 
-    internal static MetaDataClientSystem Instance { get; } = MetaDataClient.Value;
+    internal static MetaDataClientSystem Instance { get; } = MetaDataClientLazy.Value;
 
     internal bool IsWindowsEngineEnabled { get; } = Docker.System.GetSystemInfoAsync().GetAwaiter().GetResult().OperatingSystem.Contains("Windows");
   }

diff --git a/src/DotNet.Testcontainers/Clients/TestcontainersClient.cs b/src/DotNet.Testcontainers/Clients/TestcontainersClient.cs
@@ -1,31 +1,49 @@
 namespace DotNet.Testcontainers.Clients
 {
   using System;
+  using System.Diagnostics;
   using System.IO;
   using System.Threading;
   using System.Threading.Tasks;
   using Docker.DotNet.Models;
-  using DotNet.Testcontainers.Core;
+  using DotNet.Testcontainers.Core.Archive;
   using DotNet.Testcontainers.Core.Mapper;
   using DotNet.Testcontainers.Core.Models;
   using DotNet.Testcontainers.Core.Wait;
   using DotNet.Testcontainers.Diagnostics;
+  using Microsoft.Extensions.Logging;
 
   internal class TestcontainersClient : DockerApiClient, ITestcontainersClient
   {
-    private static readonly Lazy<ITestcontainersClient> Testcontainers = new Lazy<ITestcontainersClient>(() => new TestcontainersClient());
+    private static readonly Lazy<ITestcontainersClient> TestcontainersClientLazy = new Lazy<ITestcontainersClient>(() => new TestcontainersClient());
+
+    private static readonly ILogger<TestcontainersClient> Log = TestcontainersHost.GetLogger<TestcontainersClient>();
 
     private TestcontainersClient()
     {
+      AppDomain.CurrentDomain.ProcessExit += (sender, args) => PurgeOrphanedContainers();
+      Console.CancelKeyPress += (sender, args) => PurgeOrphanedContainers();
     }
 
-    internal static ITestcontainersClient Instance { get; } = Testcontainers.Value;
+    internal static ITestcontainersClient Instance { get; } = TestcontainersClientLazy.Value;
+
+    private static void PurgeOrphanedContainers()
+    {
+      var args = string.Join(" ", ContainerRegistry.GetRegisteredContainers());
+
+      if (string.IsNullOrEmpty(args))
+      {
+        return;
+      }
+
+      new Process { StartInfo = { FileName = "docker", Arguments = $"rm --force {args}" } }.Start();
+    }
 
     public async Task StartAsync(string id, CancellationToken cancellationToken = default)
     {
       if (await MetaDataClientContainers.Instance.ExistsWithIdAsync(id))
       {
-        await Docker.Containers.StartContainerAsync(id, new ContainerStartParameters { }, cancellationToken);
+        await Docker.Containers.StartContainerAsync(id, new ContainerStartParameters(), cancellationToken);
       }
     }
 
@@ -43,6 +61,8 @@ public async Task RemoveAsync(string id, CancellationToken cancellationToken = d
       {
         await Docker.Containers.RemoveContainerAsync(id, new ContainerRemoveParameters { Force = true }, cancellationToken);
       }
+
+      ContainerRegistry.Unregister(id);
     }
 
     public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken cancellationToken = default)
@@ -155,7 +175,11 @@ public async Task<string> RunAsync(TestcontainersConfiguration config, Cancellat
 
       await pullImageTask;
 
-      return (await Docker.Containers.CreateContainerAsync(createParameters, cancellationToken)).ID;
+      var id = (await Docker.Containers.CreateContainerAsync(createParameters, cancellationToken)).ID;
+
+      ContainerRegistry.Register(id, config.CleanUp);
+
+      return id;
     }
   }
 }
diff --git a/....Testcontainers/Core/DockerfileArchive.cs → ...tainers/Core/Archive/DockerfileArchive.cs b/....Testcontainers/Core/DockerfileArchive.cs → ...tainers/Core/Archive/DockerfileArchive.cs
@@ -1,4 +1,4 @@
-namespace DotNet.Testcontainers.Core
+namespace DotNet.Testcontainers.Core.Archive
 {
   using System;
   using System.IO;

diff --git a/...DotNet.Testcontainers/Core/ITarArchive.cs → ...estcontainers/Core/Archive/ITarArchive.cs b/...DotNet.Testcontainers/Core/ITarArchive.cs → ...estcontainers/Core/Archive/ITarArchive.cs
@@ -1,4 +1,4 @@
-namespace DotNet.Testcontainers.Core
+namespace DotNet.Testcontainers.Core.Archive
 {
   internal interface ITarArchive
   {

diff --git a/src/DotNet.Testcontainers/Core/Containers/TestcontainersContainer.cs b/src/DotNet.Testcontainers/Core/Containers/TestcontainersContainer.cs
@@ -11,6 +11,8 @@ namespace DotNet.Testcontainers.Core.Containers
 
   public class TestcontainersContainer : IDockerContainer
   {
+    private const string ContainerIsNotRunning = "Testcontainer is not running.";
+
     private bool disposed;
 
     private string id;
@@ -49,7 +51,7 @@ public string Name
       {
         if (this.container == null)
         {
-          throw new InvalidOperationException("Testcontainer is not running.");
+          throw new InvalidOperationException(ContainerIsNotRunning);
         }
 
         return this.container.Names.FirstOrDefault() ?? string.Empty;
@@ -62,7 +64,7 @@ public string IPAddress
       {
         if (this.container == null)
         {
-          throw new InvalidOperationException("Testcontainer is not running.");
+          throw new InvalidOperationException(ContainerIsNotRunning);
         }
 
         var ipAddress = this.container.NetworkSettings.Networks.FirstOrDefault();
@@ -76,7 +78,7 @@ public string MacAddress
       {
         if (this.container == null)
         {
-          throw new InvalidOperationException("Testcontainer is not running.");
+          throw new InvalidOperationException(ContainerIsNotRunning);
         }
 
         var macAddress = this.container.NetworkSettings.Networks.FirstOrDefault();
@@ -95,7 +97,7 @@ public int GetMappedPublicPort(string privatePort)
     {
       if (this.container == null)
       {
-        throw new InvalidOperationException("Testcontainer is not running.");
+        throw new InvalidOperationException(ContainerIsNotRunning);
       }
 
       var mappedPort = this.container.Ports.FirstOrDefault(port => $"{port.PrivatePort}".Equals(privatePort));

diff --git a/src/DotNet.Testcontainers/Diagnostics/DebugProgress.cs b/src/DotNet.Testcontainers/Diagnostics/DebugProgress.cs
@@ -6,9 +6,9 @@ namespace DotNet.Testcontainers.Diagnostics
 
   internal sealed class DebugProgress : IProgress<JSONMessage>
   {
-    private static readonly Lazy<DebugProgress> Progress = new Lazy<DebugProgress>(() => new DebugProgress());
+    private static readonly Lazy<DebugProgress> DebugProgressLazy = new Lazy<DebugProgress>(() => new DebugProgress());
 
-    public static DebugProgress Instance => Progress.Value;
+    public static DebugProgress Instance => DebugProgressLazy.Value;
 
     public void Report(JSONMessage value)
     {

diff --git a/src/DotNet.Testcontainers/TestcontainersHost.cs b/src/DotNet.Testcontainers/TestcontainersHost.cs
@@ -5,6 +5,7 @@ namespace DotNet.Testcontainers
   using Microsoft.Extensions.Hosting;
   using Microsoft.Extensions.Logging;
   using Serilog;
+  using ILogger = Microsoft.Extensions.Logging.ILogger;
 
   internal static class TestcontainersHost
   {
@@ -25,6 +26,11 @@ static TestcontainersHost()
         .Build();
     }
 
+    internal static ILogger GetLogger(string categoryName)
+    {
+      return host.Services.GetRequiredService<ILoggerFactory>().CreateLogger(categoryName);
+    }
+
     internal static ILogger<T> GetLogger<T>()
     {
       return host.Services.GetRequiredService<ILogger<T>>();

diff --git a/template/build.yml b/template/build.yml
@@ -1,6 +1,6 @@
 jobs:
   - job: ${{ parameters.name }}
-    displayName: CI build for ${{ parameters.name }}
+    displayName: CI build for ${{ parameters.displayName }}
 
     pool:
       vmImage: ${{ parameters.vmImage }}

diff --git a/template/publish.yml b/template/publish.yml
@@ -1,20 +1,23 @@
 jobs:
   - job: ${{ parameters.name }}
-    displayName: CI build for ${{ parameters.name }}
+    displayName: CI build for ${{ parameters.displayName }}
 
     pool:
       vmImage: ${{ parameters.vmImage }}
 
     dependsOn:
-      - Windows
-      - Linux
+      - BuildAndTestOnWindows
+      - BuildAndTestOnLinux
 
     steps:
       - task: UseDotNet@2
         displayName: Use .NET Core SDK ${{ parameters.dotNetCoreVersion }}
         inputs:
           version: ${{ parameters.dotNetCoreVersion }}
 
+      - powershell: dotnet tool install --tool-path ./tools --version ${{ parameters.cakeVersion }} Cake.Tool
+        displayName: Setup prerequisites
+
       - powershell: ./tools/dotnet-cake --target=Sonar
         displayName: Sonar
         env: