WireMock.Net.Testcontainers: implement watching the static mapping folder for changes (#1189)

* WireMock.Net.Testcontainers: implement watching the static mapping files + folder for changes

* ReloadStaticMappings

* fix

* .

* .

* .

* .

* .

* .

* .

* CopyAsync

* <VersionPrefix>1.6.7-preview-02</VersionPrefix>

* <VersionPrefix>1.6.7-preview-03</VersionPrefix>

src/WireMock.Net.Aspire/Extensions/ResourceLoggerServiceExtensions.cs

@@ -0,0 +1,14 @@
+// Copyright © WireMock.Net
+
+using Aspire.Hosting.ApplicationModel;
+
+namespace WireMock.Net.Aspire.Extensions;
+
+internal static class ResourceLoggerServiceExtensions
+{
+    public static void SetLogger(this ResourceLoggerService resourceLoggerService, WireMockServerResource wireMockServerResource)
+    {
+        var logger = resourceLoggerService.GetLogger(wireMockServerResource);
+        wireMockServerResource.SetLogger(logger);
+    }
+}

src/WireMock.Net.Aspire/WireMock.Net.Aspire.csproj

@@ -30,6 +30,10 @@
         <None Include="../../resources/WireMock.Net-LogoAspire.png" Pack="true" PackagePath="" />
     </ItemGroup>
 
+    <ItemGroup>
+        <Compile Include="..\WireMock.Net\Util\EnhancedFileSystemWatcher.cs" Link="Utils\EnhancedFileSystemWatcher.cs" />
+    </ItemGroup>
+
     <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     </PropertyGroup>

src/WireMock.Net.Aspire/WireMockServerArguments.cs

@@ -50,7 +50,7 @@ public class WireMockServerArguments
     ///
     /// Default value is <c>false</c>.
     /// </summary>
-    public bool WithWatchStaticMappings { get; set; }
+    public bool WatchStaticMappings { get; set; }
 
     /// <summary>
     /// Specifies the path for the (static) mapping json files.
@@ -65,7 +65,7 @@ public class WireMockServerArguments
     /// <summary>
     /// Optional delegate that will be invoked to configure the WireMock.Net resource using the <see cref="AdminApiMappingBuilder"/>.
     /// </summary>
-    public Func<AdminApiMappingBuilder, Task>? ApiMappingBuilder { get; set; }
+    public Func<AdminApiMappingBuilder, CancellationToken, Task>? ApiMappingBuilder { get; set; }
 
     /// <summary>
     /// Converts the current instance's properties to an array of command-line arguments for starting the WireMock.Net server.
@@ -88,7 +88,7 @@ public class WireMockServerArguments
             Add(args, "--ReadStaticMappings", "true");
         }
 
-        if (WithWatchStaticMappings)
+        if (WatchStaticMappings)
         {
             Add(args, "--ReadStaticMappings", "true");
             Add(args, "--WatchStaticMappings", "true");

src/WireMock.Net.Aspire/WireMockServerBuilderExtensions.cs

@@ -112,7 +112,7 @@ public static class WireMockServerBuilderExtensions
     /// <returns>A reference to the <see cref="IResourceBuilder{WireMockServerResource}"/>.</returns>
     public static IResourceBuilder<WireMockServerResource> WithWatchStaticMappings(this IResourceBuilder<WireMockServerResource> wiremock)
     {
-        Guard.NotNull(wiremock).Resource.Arguments.WithWatchStaticMappings = true;
+        Guard.NotNull(wiremock).Resource.Arguments.WatchStaticMappings = true;
         return wiremock;
     }
 
@@ -124,8 +124,10 @@ public static class WireMockServerBuilderExtensions
     /// <returns>A reference to the <see cref="IResourceBuilder{WireMockServerResource}"/>.</returns>
     public static IResourceBuilder<WireMockServerResource> WithMappingsPath(this IResourceBuilder<WireMockServerResource> wiremock, string mappingsPath)
     {
-        return Guard.NotNull(wiremock)
-            .WithBindMount(Guard.NotNullOrWhiteSpace(mappingsPath), DefaultLinuxMappingsPath);
+        Guard.NotNullOrWhiteSpace(mappingsPath);
+        Guard.NotNull(wiremock).Resource.Arguments.MappingsPath = mappingsPath;
+
+        return wiremock.WithBindMount(mappingsPath, DefaultLinuxMappingsPath);
     }
 
     /// <summary>
@@ -151,6 +153,17 @@ public static class WireMockServerBuilderExtensions
     /// <param name="configure">Delegate that will be invoked to configure the WireMock.Net resource.</param>
     /// <returns></returns>
     public static IResourceBuilder<WireMockServerResource> WithApiMappingBuilder(this IResourceBuilder<WireMockServerResource> wiremock, Func<AdminApiMappingBuilder, Task> configure)
+    {
+        return wiremock.WithApiMappingBuilder((adminApiMappingBuilder, _) => configure.Invoke(adminApiMappingBuilder));
+    }
+
+    /// <summary>
+    /// Use WireMock Client's AdminApiMappingBuilder to configure the WireMock.Net resource.
+    /// </summary>
+    /// <param name="wiremock">The <see cref="IResourceBuilder{WireMockServerResource}"/>.</param>
+    /// <param name="configure">Delegate that will be invoked to configure the WireMock.Net resource.</param>
+    /// <returns></returns>
+    public static IResourceBuilder<WireMockServerResource> WithApiMappingBuilder(this IResourceBuilder<WireMockServerResource> wiremock, Func<AdminApiMappingBuilder, CancellationToken, Task> configure)
     {
         Guard.NotNull(wiremock);
 

src/WireMock.Net.Aspire/WireMockServerLifecycleHook.cs

@@ -3,50 +3,39 @@
 using Aspire.Hosting.ApplicationModel;
 using Aspire.Hosting.Lifecycle;
 using Microsoft.Extensions.Logging;
-using RestEase;
-using WireMock.Client;
-using WireMock.Client.Extensions;
 
 namespace WireMock.Net.Aspire;
 
-internal class WireMockServerLifecycleHook(ResourceLoggerService loggerService) : IDistributedApplicationLifecycleHook
+internal class WireMockServerLifecycleHook(ILoggerFactory loggerFactory) : IDistributedApplicationLifecycleHook, IAsyncDisposable
 {
+    private readonly CancellationTokenSource _shutdownCts = new();
+
     public async Task AfterResourcesCreatedAsync(DistributedApplicationModel appModel, CancellationToken cancellationToken = default)
     {
+        var cts = CancellationTokenSource.CreateLinkedTokenSource(_shutdownCts.Token, cancellationToken);
+
         var wireMockServerResources = appModel.Resources
             .OfType<WireMockServerResource>()
-            .Where(resource => resource.Arguments.ApiMappingBuilder is not null)
             .ToArray();
 
-        if (wireMockServerResources.Length == 0)
-        {
-            return;
-        }
-
         foreach (var wireMockServerResource in wireMockServerResources)
         {
+            wireMockServerResource.SetLogger(loggerFactory.CreateLogger<WireMockServerResource>());
+
             var endpoint = wireMockServerResource.GetEndpoint();
             if (endpoint.IsAllocated)
             {
-                var adminApi = CreateWireMockAdminApi(wireMockServerResource);
+                await wireMockServerResource.WaitForHealthAsync(cts.Token);
 
-                var logger = loggerService.GetLogger(wireMockServerResource);
-                logger.LogInformation("Checking Health status from WireMock.Net");
+                await wireMockServerResource.CallApiMappingBuilderActionAsync(cts.Token);
 
-                await adminApi.WaitForHealthAsync(cancellationToken: cancellationToken);
-
-                logger.LogInformation("Calling ApiMappingBuilder to add mappings to WireMock.Net");
-                var mappingBuilder = adminApi.GetMappingBuilder();
-                await wireMockServerResource.Arguments.ApiMappingBuilder!.Invoke(mappingBuilder);
+                wireMockServerResource.StartWatchingStaticMappings(cts.Token);
             }
         }
     }
 
-    private static IWireMockAdminApi CreateWireMockAdminApi(WireMockServerResource resource)
+    public async ValueTask DisposeAsync()
     {
-        var adminApi = RestClient.For<IWireMockAdminApi>(resource.GetEndpoint().Url);
-        return resource.Arguments.HasBasicAuthentication ?
-            adminApi.WithAuthorization(resource.Arguments.AdminUsername!, resource.Arguments.AdminPassword!) :
-            adminApi;
+        await _shutdownCts.CancelAsync();
     }
 }

src/WireMock.Net.Aspire/WireMockServerResource.cs

@@ -1,6 +1,11 @@
 // Copyright © WireMock.Net
 
+using Microsoft.Extensions.Logging;
+using RestEase;
 using Stef.Validation;
+using WireMock.Client;
+using WireMock.Client.Extensions;
+using WireMock.Util;
 
 // ReSharper disable once CheckNamespace
 namespace Aspire.Hosting.ApplicationModel;
@@ -10,7 +15,13 @@ namespace Aspire.Hosting.ApplicationModel;
 /// </summary>
 public class WireMockServerResource : ContainerResource, IResourceWithServiceDiscovery
 {
+    private const int EnhancedFileSystemWatcherTimeoutMs = 2000;
+
     internal WireMockServerArguments Arguments { get; }
+    internal Lazy<IWireMockAdminApi> AdminApi => new(CreateWireMockAdminApi);
+
+    private ILogger? _logger;
+    private EnhancedFileSystemWatcher? _enhancedFileSystemWatcher;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="WireMockServerResource"/> class.
@@ -30,4 +41,82 @@ public class WireMockServerResource : ContainerResource, IResourceWithServiceDis
     {
         return new EndpointReference(this, "http");
     }
+
+    internal void SetLogger(ILogger logger)
+    {
+        _logger = logger;
+    }
+
+    internal async Task WaitForHealthAsync(CancellationToken cancellationToken)
+    {
+        _logger?.LogInformation("Checking Health status from WireMock.Net");
+        await AdminApi.Value.WaitForHealthAsync(cancellationToken: cancellationToken);
+    }
+
+    internal async Task CallApiMappingBuilderActionAsync(CancellationToken cancellationToken)
+    {
+        if (Arguments.ApiMappingBuilder == null)
+        {
+            return;
+        }
+
+        _logger?.LogInformation("Calling ApiMappingBuilder to add mappings to WireMock.Net");
+
+        var mappingBuilder = AdminApi.Value.GetMappingBuilder();
+        await Arguments.ApiMappingBuilder.Invoke(mappingBuilder, cancellationToken);
+    }
+
+    internal void StartWatchingStaticMappings(CancellationToken cancellationToken)
+    {
+        if (!Arguments.WatchStaticMappings || string.IsNullOrEmpty(Arguments.MappingsPath))
+        {
+            return;
+        }
+
+        cancellationToken.Register(() =>
+        {
+            if (_enhancedFileSystemWatcher != null)
+            {
+                _enhancedFileSystemWatcher.EnableRaisingEvents = false;
+                _enhancedFileSystemWatcher.Created -= FileCreatedChangedOrDeleted;
+                _enhancedFileSystemWatcher.Changed -= FileCreatedChangedOrDeleted;
+                _enhancedFileSystemWatcher.Deleted -= FileCreatedChangedOrDeleted;
+
+                _enhancedFileSystemWatcher.Dispose();
+                _enhancedFileSystemWatcher = null;
+            }
+        });
+
+        _logger?.LogInformation("Starting to watch static mappings on path: '{Path}'. ", Arguments.MappingsPath);
+
+        _enhancedFileSystemWatcher = new EnhancedFileSystemWatcher(Arguments.MappingsPath, "*.json", EnhancedFileSystemWatcherTimeoutMs)
+        {
+            IncludeSubdirectories = true
+        };
+        _enhancedFileSystemWatcher.Created += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.Changed += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.Deleted += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.EnableRaisingEvents = true;
+    }
+
+    private IWireMockAdminApi CreateWireMockAdminApi()
+    {
+        var adminApi = RestClient.For<IWireMockAdminApi>(GetEndpoint().Url);
+        return Arguments.HasBasicAuthentication ?
+            adminApi.WithAuthorization(Arguments.AdminUsername!, Arguments.AdminPassword!) :
+            adminApi;
+    }
+
+    private async void FileCreatedChangedOrDeleted(object sender, FileSystemEventArgs args)
+    {
+        _logger?.LogInformation("MappingFile created, changed or deleted: '{0}'. Triggering ReloadStaticMappings.", args.FullPath);
+        try
+        {
+            await AdminApi.Value.ReloadStaticMappingsAsync();
+        }
+        catch (Exception ex)
+        {
+            _logger?.LogWarning(ex, "Error calling /__admin/mappings/reloadStaticMappings");
+        }
+    }
 }

src/WireMock.Net.RestClient/Extensions/WireMockAdminApiExtensions.cs

@@ -72,7 +72,7 @@ public static class WireMockAdminApiExtensions
 
         if (retries >= MaxRetries)
         {
-            throw new InvalidOperationException($"The /__admin/health endpoint did not return 'Healthy' after {MaxRetries} retries and {totalWaitTime / 1000.0:0.0} seconds.");
+            throw new InvalidOperationException($"The /__admin/health endpoint did not return '{HealthStatusHealthy}' after {MaxRetries} retries and {totalWaitTime / 1000.0:0.0} seconds.");
         }
     }
 

src/WireMock.Net.RestClient/IWireMockAdminApi.cs

@@ -122,6 +122,13 @@ public interface IWireMockAdminApi
     [Post("mappings/reset")]
     Task<StatusModel> ResetMappingsAsync(bool? reloadStaticMappings = false, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Reload the static mappings.
+    /// </summary>
+    /// <param name="cancellationToken">The optional cancellationToken.</param>
+    [Post("mappings/reloadStaticMappings")]
+    Task<StatusModel> ReloadStaticMappingsAsync(CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Get a mapping based on the guid
     /// </summary>

src/WireMock.Net.Testcontainers/Utils/ContainerInfoProvider.cs

@@ -0,0 +1,16 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using WireMock.Net.Testcontainers.Models;
+
+namespace WireMock.Net.Testcontainers.Utils;
+
+internal static class ContainerInfoProvider
+{
+    public static readonly Dictionary<OSPlatform, ContainerInfo> Info = new()
+    {
+        { OSPlatform.Linux, new ContainerInfo("sheyenrath/wiremock.net-alpine", "/app/__admin/mappings") },
+        { OSPlatform.Windows, new ContainerInfo("sheyenrath/wiremock.net-windows", @"c:\app\__admin\mappings") }
+    };
+}

src/WireMock.Net.Testcontainers/Utils/ContainerUtils.cs

@@ -0,0 +1,25 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Runtime.InteropServices;
+using DotNet.Testcontainers.Configurations;
+using System.Threading.Tasks;
+
+namespace WireMock.Net.Testcontainers.Utils;
+
+internal static class ContainerUtils
+{
+    public static Lazy<Task<OSPlatform>> GetImageOSAsync = new(async () =>
+    {
+        if (TestcontainersSettings.OS.DockerEndpointAuthConfig == null)
+        {
+            throw new InvalidOperationException($"The {nameof(TestcontainersSettings.OS.DockerEndpointAuthConfig)} is null. Check if Docker is started.");
+        }
+
+        using var dockerClientConfig = TestcontainersSettings.OS.DockerEndpointAuthConfig.GetDockerClientConfiguration();
+        using var dockerClient = dockerClientConfig.CreateClient();
+
+        var version = await dockerClient.System.GetVersionAsync();
+        return version.Os.IndexOf("Windows", StringComparison.OrdinalIgnoreCase) >= 0 ? OSPlatform.Windows : OSPlatform.Linux;
+    });
+}

src/WireMock.Net.Testcontainers/WireMock.Net.Testcontainers.csproj

@@ -20,6 +20,7 @@
 
     <ItemGroup>
       <Compile Include="..\WireMock.Net\Http\HttpClientFactory2.cs" Link="Http\HttpClientFactory2.cs" />
+      <Compile Include="..\WireMock.Net\Util\EnhancedFileSystemWatcher.cs" Link="Utils\EnhancedFileSystemWatcher.cs" />
     </ItemGroup>
 
     <ItemGroup>

src/WireMock.Net.Testcontainers/WireMockConfiguration.cs

@@ -1,6 +1,5 @@
 // Copyright © WireMock.Net
 
-using System;
 using Docker.DotNet.Models;
 using DotNet.Testcontainers.Builders;
 using DotNet.Testcontainers.Configurations;
@@ -19,6 +18,10 @@ public sealed class WireMockConfiguration : ContainerConfiguration
 
     public string? StaticMappingsPath { get; private set; }
 
+    public bool WatchStaticMappings { get; private set; }
+
+    public bool WatchStaticMappingsInSubdirectories { get; private set; }
+
     public bool HasBasicAuthentication => !string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password);
 
     public WireMockConfiguration(string? username = null, string? password = null)
@@ -65,16 +68,30 @@ public sealed class WireMockConfiguration : ContainerConfiguration
         Username = BuildConfiguration.Combine(oldValue.Username, newValue.Username);
         Password = BuildConfiguration.Combine(oldValue.Password, newValue.Password);
         StaticMappingsPath = BuildConfiguration.Combine(oldValue.StaticMappingsPath, newValue.StaticMappingsPath);
+        WatchStaticMappings = BuildConfiguration.Combine(oldValue.WatchStaticMappings, newValue.WatchStaticMappings);
+        WatchStaticMappingsInSubdirectories = BuildConfiguration.Combine(oldValue.WatchStaticMappingsInSubdirectories, newValue.WatchStaticMappingsInSubdirectories);
     }
 
     /// <summary>
     /// Set the StaticMappingsPath.
     /// </summary>
     /// <param name="path">The path which contains the StaticMappings.</param>
-    /// <returns><see cref="WireMockConfiguration"/> </returns>
+    /// <returns><see cref="WireMockConfiguration"/></returns>
     public WireMockConfiguration WithStaticMappingsPath(string path)
     {
         StaticMappingsPath = path;
         return this;
     }
+
+    /// <summary>
+    /// Watch the static mappings.
+    /// </summary>
+    /// <param name="includeSubDirectories">Also look in SubDirectories.</param>
+    /// <returns><see cref="WireMockConfiguration"/></returns>
+    public WireMockConfiguration WithWatchStaticMappings(bool includeSubDirectories)
+    {
+        WatchStaticMappings = true;
+        WatchStaticMappingsInSubdirectories = includeSubDirectories;
+        return this;
+    }
 }

src/WireMock.Net.Testcontainers/WireMockContainer.cs

@@ -1,14 +1,20 @@
 // Copyright © WireMock.Net
 
 using System;
+using System.IO;
 using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using DotNet.Testcontainers.Configurations;
 using DotNet.Testcontainers.Containers;
 using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
 using RestEase;
-using Stef.Validation;
 using WireMock.Client;
 using WireMock.Client.Extensions;
 using WireMock.Http;
+using WireMock.Net.Testcontainers.Utils;
+using WireMock.Util;
 
 namespace WireMock.Net.Testcontainers;
 
@@ -17,17 +23,23 @@ namespace WireMock.Net.Testcontainers;
 /// </summary>
 public sealed class WireMockContainer : DockerContainer
 {
+    private const int EnhancedFileSystemWatcherTimeoutMs = 2000;
     internal const int ContainerPort = 80;
 
     private readonly WireMockConfiguration _configuration;
 
+    private IWireMockAdminApi? _adminApi;
+    private EnhancedFileSystemWatcher? _enhancedFileSystemWatcher;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="WireMockContainer" /> class.
     /// </summary>
     /// <param name="configuration">The container configuration.</param>
     public WireMockContainer(WireMockConfiguration configuration) : base(configuration)
     {
-        _configuration = Guard.NotNull(configuration);
+        _configuration = Stef.Validation.Guard.NotNull(configuration);
+
+        Started += WireMockContainer_Started;
     }
 
     /// <summary>
@@ -92,6 +104,71 @@ public sealed class WireMockContainer : DockerContainer
         return client;
     }
 
+    /// <summary>
+    /// Copies a test host directory or file to the container and triggers a reload of the static mappings if required.
+    /// </summary>
+    /// <param name="source">The source directory or file to be copied.</param>
+    /// <param name="target">The target directory path to copy the files to.</param>
+    /// <param name="fileMode">The POSIX file mode permission.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>A task that completes when the directory or file has been copied.</returns>
+    public new async Task CopyAsync(string source, string target, UnixFileModes fileMode = Unix.FileMode644, CancellationToken ct = default)
+    {
+        await base.CopyAsync(source, target, fileMode, ct);
+
+        if (_configuration.WatchStaticMappings && await PathStartsWithContainerMappingsPath(target))
+        {
+            await ReloadStaticMappingsAsync(target, ct);
+        }
+    }
+    
+    /// <summary>
+    /// Reload the static mappings.
+    /// </summary>
+    /// <param name="cancellationToken">The optional cancellationToken.</param>
+    public async Task ReloadStaticMappingsAsync(CancellationToken cancellationToken = default)
+    {
+        if (_adminApi == null)
+        {
+            return;
+        }
+
+        try
+        {
+            await _adminApi.ReloadStaticMappingsAsync(cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Error calling /__admin/mappings/reloadStaticMappings");
+        }
+    }
+
+    /// <inheritdoc />
+    protected override ValueTask DisposeAsyncCore()
+    {
+        if (_enhancedFileSystemWatcher != null)
+        {
+            _enhancedFileSystemWatcher.EnableRaisingEvents = false;
+            _enhancedFileSystemWatcher.Created -= FileCreatedChangedOrDeleted;
+            _enhancedFileSystemWatcher.Changed -= FileCreatedChangedOrDeleted;
+            _enhancedFileSystemWatcher.Deleted -= FileCreatedChangedOrDeleted;
+
+            _enhancedFileSystemWatcher.Dispose();
+            _enhancedFileSystemWatcher = null;
+        }
+
+        Started -= WireMockContainer_Started;
+
+        return base.DisposeAsyncCore();
+    }
+
+    private static async Task<bool> PathStartsWithContainerMappingsPath(string value)
+    {
+        var imageOs = await ContainerUtils.GetImageOSAsync.Value;
+
+        return value.StartsWith(ContainerInfoProvider.Info[imageOs].MappingsPath);
+    }
+
     private void ValidateIfRunning()
     {
         if (State != TestcontainersStates.Running)
@@ -100,5 +177,35 @@ public sealed class WireMockContainer : DockerContainer
         }
     }
 
+    private void WireMockContainer_Started(object sender, EventArgs e)
+    {
+        _adminApi = CreateWireMockAdminClient();
+
+        if (!_configuration.WatchStaticMappings || string.IsNullOrEmpty(_configuration.StaticMappingsPath))
+        {
+            return;
+        }
+
+        _enhancedFileSystemWatcher = new EnhancedFileSystemWatcher(_configuration.StaticMappingsPath!, "*.json", EnhancedFileSystemWatcherTimeoutMs)
+        {
+            IncludeSubdirectories = _configuration.WatchStaticMappingsInSubdirectories
+        };
+        _enhancedFileSystemWatcher.Created += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.Changed += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.Deleted += FileCreatedChangedOrDeleted;
+        _enhancedFileSystemWatcher.EnableRaisingEvents = true;
+    }
+
+    private async void FileCreatedChangedOrDeleted(object sender, FileSystemEventArgs args)
+    {
+        await ReloadStaticMappingsAsync(args.FullPath);
+    }
+
+    private async Task ReloadStaticMappingsAsync(string path, CancellationToken cancellationToken = default)
+    {
+        Logger.LogInformation("MappingFile created, changed or deleted: '{Path}'. Triggering ReloadStaticMappings.", path);
+        await ReloadStaticMappingsAsync(cancellationToken);
+    }
+
     private Uri GetPublicUri() => new UriBuilder(Uri.UriSchemeHttp, Hostname, GetMappedPublicPort(ContainerPort)).Uri;
 }

src/WireMock.Net.Testcontainers/WireMockContainerBuilder.cs

@@ -1,15 +1,13 @@
 // Copyright © WireMock.Net
 
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using Docker.DotNet.Models;
 using DotNet.Testcontainers.Builders;
 using DotNet.Testcontainers.Configurations;
 using JetBrains.Annotations;
 using Stef.Validation;
-using WireMock.Net.Testcontainers.Models;
+using WireMock.Net.Testcontainers.Utils;
 
 namespace WireMock.Net.Testcontainers;
 
@@ -19,26 +17,6 @@ namespace WireMock.Net.Testcontainers;
 public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContainerBuilder, WireMockContainer, WireMockConfiguration>
 {
     private const string DefaultLogger = "WireMockConsoleLogger";
-    private readonly Dictionary<OSPlatform, ContainerInfo> _info = new()
-    {
-        { OSPlatform.Linux, new ContainerInfo("sheyenrath/wiremock.net-alpine", "/app/__admin/mappings") },
-        { OSPlatform.Windows, new ContainerInfo("sheyenrath/wiremock.net-windows", @"c:\app\__admin\mappings") }
-    };
-
-    private readonly Lazy<Task<OSPlatform>> _getOSAsLazy = new(async () =>
-    {
-        if (TestcontainersSettings.OS.DockerEndpointAuthConfig == null)
-        {
-            throw new InvalidOperationException($"The {nameof(TestcontainersSettings.OS.DockerEndpointAuthConfig)} is null. Check if Docker is started.");
-        }
-
-        using var dockerClientConfig = TestcontainersSettings.OS.DockerEndpointAuthConfig.GetDockerClientConfiguration();
-        using var dockerClient = dockerClientConfig.CreateClient();
-
-        var version = await dockerClient.System.GetVersionAsync();
-        return version.Os.IndexOf("Windows", StringComparison.OrdinalIgnoreCase) >= 0 ? OSPlatform.Windows : OSPlatform.Linux;
-    });
-
     private OSPlatform? _imageOS;
 
     /// <summary>
@@ -58,7 +36,7 @@ public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContaine
     [PublicAPI]
     public WireMockContainerBuilder WithImage()
     {
-        _imageOS ??= _getOSAsLazy.Value.GetAwaiter().GetResult();
+        _imageOS ??= ContainerUtils.GetImageOSAsync.Value.GetAwaiter().GetResult();
         return WithImage(_imageOS.Value);
     }
 
@@ -130,7 +108,9 @@ public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContaine
     [PublicAPI]
     public WireMockContainerBuilder WithWatchStaticMappings(bool includeSubDirectories)
     {
-        return WithCommand("--WatchStaticMappings true").WithCommand($"--WatchStaticMappingsInSubdirectories {includeSubDirectories}");
+        return Merge(DockerResourceConfiguration, DockerResourceConfiguration.WithWatchStaticMappings(includeSubDirectories))
+            .WithCommand("--WatchStaticMappings true")
+            .WithCommand($"--WatchStaticMappingsInSubdirectories {includeSubDirectories}");
     }
 
     /// <summary>
@@ -181,7 +161,7 @@ public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContaine
 
         if (!string.IsNullOrEmpty(builder.DockerResourceConfiguration.StaticMappingsPath))
         {
-            builder = builder.WithBindMount(builder.DockerResourceConfiguration.StaticMappingsPath, _info[_imageOS.Value].MappingsPath);
+            builder = builder.WithBindMount(builder.DockerResourceConfiguration.StaticMappingsPath, ContainerInfoProvider.Info[_imageOS.Value].MappingsPath);
         }
 
         builder.Validate();
@@ -198,7 +178,7 @@ public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContaine
         return builder
             .WithPortBinding(WireMockContainer.ContainerPort, true)
             .WithCommand($"--WireMockLogger {DefaultLogger}")
-            .WithWaitStrategy(waitForContainerOS.UntilMessageIsLogged("By Stef Heyenrath"));
+            .WithWaitStrategy(waitForContainerOS.UntilMessageIsLogged("WireMock.Net server running"));
     }
 
     /// <inheritdoc />
@@ -222,6 +202,6 @@ public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContaine
     private WireMockContainerBuilder WithImage(OSPlatform os)
     {
         _imageOS = os;
-        return WithImage(_info[os].Image);
+        return WithImage(ContainerInfoProvider.Info[os].Image);
     }
 }

src/WireMock.Net/Server/WireMockServer.Admin.cs

@@ -96,6 +96,9 @@ public partial class WireMockServer
         // __admin/mappings/reset
         Given(Request.Create().WithPath(_adminPaths.Mappings + "/reset").UsingPost()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(MappingsReset));
 
+        // __admin/mappings/reloadStaticMappings
+        Given(Request.Create().WithPath(_adminPaths.Mappings + "/reloadStaticMappings").UsingPost()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(ReloadStaticMappings));
+
         // __admin/mappings/{guid}
         Given(Request.Create().WithPath(_adminPaths.MappingsGuidPathMatcher).UsingGet()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(MappingGet));
         Given(Request.Create().WithPath(_adminPaths.MappingsGuidPathMatcher).UsingPut().WithHeader(HttpKnownHeaderNames.ContentType, AdminRequestContentTypeJson)).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(MappingPut));
@@ -170,9 +173,9 @@ public partial class WireMockServer
             return;
         }
 
-        foreach (string filename in _settings.FileSystemHandler.EnumerateFiles(folder, _settings.WatchStaticMappingsInSubdirectories == true).OrderBy(f => f))
+        foreach (var filename in _settings.FileSystemHandler.EnumerateFiles(folder, _settings.WatchStaticMappingsInSubdirectories == true).OrderBy(f => f))
         {
-            _settings.Logger.Info("Reading Static MappingFile : '{0}'", filename);
+            _settings.Logger.Info("Reading Static MappingFile : '{0}'.", filename);
 
             try
             {
@@ -556,18 +559,25 @@ public partial class WireMockServer
 
         ResetScenarios();
 
-        string message = "Mappings reset";
+        var message = "Mappings reset";
         if (requestMessage.Query != null &&
             requestMessage.Query.ContainsKey(QueryParamReloadStaticMappings) &&
-            bool.TryParse(requestMessage.Query[QueryParamReloadStaticMappings].ToString(), out bool reloadStaticMappings) &&
+            bool.TryParse(requestMessage.Query[QueryParamReloadStaticMappings].ToString(), out var reloadStaticMappings) &&
             reloadStaticMappings)
         {
             ReadStaticMappings();
-            message = $"{message} and static mappings reloaded";
+            message += " and static mappings reloaded";
         }
 
         return ResponseMessageBuilder.Create(200, message);
     }
+
+    private IResponseMessage ReloadStaticMappings(IRequestMessage _)
+    {
+        ReadStaticMappings();
+
+        return ResponseMessageBuilder.Create(200, "Static Mappings reloaded");
+    }
     #endregion Mappings
 
     #region Request/{guid}
@@ -780,7 +790,7 @@ public partial class WireMockServer
     private void EnhancedFileSystemWatcherDeleted(object sender, FileSystemEventArgs args)
     {
         _settings.Logger.Info("MappingFile deleted : '{0}'", args.FullPath);
-        string filenameWithoutExtension = Path.GetFileNameWithoutExtension(args.FullPath);
+        var filenameWithoutExtension = Path.GetFileNameWithoutExtension(args.FullPath);
 
         if (Guid.TryParse(filenameWithoutExtension, out var guidFromFilename))
         {