Add Db2 module

Directory.Packages.props

@@ -35,6 +35,8 @@
         <PackageVersion Include="Confluent.Kafka" Version="2.0.2"/>
         <PackageVersion Include="Consul" Version="1.6.10.9"/>
         <PackageVersion Include="CouchbaseNetClient" Version="3.4.3"/>
+        <PackageVersion Include="Net.IBM.Data.Db2" Version="8.0.0.200" Condition="$([MSBuild]::IsOSPlatform('Windows'))" />
+        <PackageVersion Include="Net.IBM.Data.Db2-lnx" Version="8.0.0.200" Condition="$([MSBuild]::IsOSPlatform('Linux'))" />       
         <PackageVersion Include="DotPulsar" Version="3.3.2"/>
         <PackageVersion Include="Elastic.Clients.Elasticsearch" Version="8.0.5"/>
         <PackageVersion Include="EventStore.Client.Grpc.Streams" Version="22.0.0"/>

docs/modules/db2.md

@@ -0,0 +1,41 @@
+# IBM DB2
+
+[IBM DB2](https://www.ibm.com/db2), is a relational database engine developed by IBM. The following example provides .NET developers with a starting point to use a IBM DB2 instance in the [xUnit][xunit] tests.
+
+The following example (for windows) uses the following NuGet packages:
+
+```console title="Install the NuGet dependencies"
+dotnet add package Testcontainers.Db2
+dotnet add package Net.IBM.Data.Db2
+dotnet add package xunit
+```
+
+Please note: For linux there are currently some hurdles and the package Net.IBM.Data.Db2-lnx has to be used with the following environment variables being set:
+
+  - LD_LIBRARY_PATH
+  - PATH
+  - DB2_CLI_DRIVER_INSTALL_PATH
+
+One way to achieve this within a test project is to extend the .csproj with a task that writes a .runsettings file. An example is given below:
+
+=== "Example"
+    ```xml
+    --8<-- "tests/Testcontainers.Db2.Tests/Testcontainers.Db2.Tests.csproj:RunSettingsGeneration"
+    ```
+
+IDEs and editors may also require the following packages to run tests: `xunit.runner.visualstudio` and `Microsoft.NET.Test.Sdk`.
+
+Copy and paste the following code into a new `.cs` test file within an existing test project.
+
+=== "Usage Example"
+    ```csharp
+    --8<-- "tests/Testcontainers.Db2.Tests/Db2ContainerTest.cs:UseDb2Container"
+    ```
+
+To execute the tests, use the command `dotnet test` from a terminal.
+
+## A Note To Developers
+
+Once Testcontainers creates a server instance, developers may use the connection string with any of the popular data-access technologies found in the .NET Ecosystem. Some of these libraries include [Entity Framework Core](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore), [Dapper](https://www.nuget.org/packages/Dapper), and [NHibernate](https://www.nuget.org/packages/NHibernate). At which point, developers can execute database migrations and SQL scripts.
+
+[xunit]: https://xunit.net/

mkdocs.yml

@@ -45,6 +45,7 @@ nav:
     - examples/aspnet.md
   - Modules:
     - modules/index.md
+    - modules/db2.md
     - modules/elasticsearch.md
     - modules/mongodb.md
     - modules/mssql.md

src/Testcontainers.Db2/.editorconfig

@@ -0,0 +1 @@
+root = true

src/Testcontainers.Db2/Db2Builder.cs

@@ -0,0 +1,205 @@
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Testcontainers.Db2;
+
+/// <inheritdoc cref="ContainerBuilder{TBuilderEntity, TContainerEntity, TConfigurationEntity}" />
+[PublicAPI]
+public sealed class Db2Builder : ContainerBuilder<Db2Builder, Db2Container, Db2Configuration>
+{
+  public const string Db2Image = "icr.io/db2_community/db2:latest";
+
+  public const ushort Db2Port = 50000;
+
+  public const string DefaultDatabase = "test";
+
+  public const string DefaultUsername = "db2inst1";
+
+  public const string DefaultPassword = "test123";
+
+  public const string DefaultLicenseAgreement = "accept";
+
+  public const string DefaultInMemoryDatabasePath = "/home/db2inst1/data";
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Builder" /> class.
+  /// </summary>
+  public Db2Builder()
+      : this(new Db2Configuration())
+  {
+    DockerResourceConfiguration = Init().DockerResourceConfiguration;
+  }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Builder" /> class.
+  /// </summary>
+  /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+  private Db2Builder(Db2Configuration resourceConfiguration)
+      : base(resourceConfiguration)
+  {
+    DockerResourceConfiguration = resourceConfiguration;
+  }
+
+  /// <inheritdoc />
+  protected override Db2Configuration DockerResourceConfiguration { get; }
+
+  /// <summary>
+  /// Sets the Db2 database name.
+  /// </summary>
+  /// <param name="database">The Db2 database.</param>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithDatabase(string database)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(database: database))
+        .WithEnvironment("DBNAME", database);
+  }
+
+  /// <summary>
+  /// Sets the Db2 username.
+  /// </summary>
+  /// <param name="username">The Db2 username.</param>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithUsername(string username)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(username: username))
+        .WithEnvironment("DB2INSTANCE", username);
+  }
+
+  /// <summary>
+  /// Sets the Db2 password.
+  /// </summary>
+  /// <param name="password">The Db2 password.</param>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithPassword(string password)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(password: password))
+        .WithEnvironment("DB2INST1_PASSWORD", password);
+  }
+
+  /// <summary>
+  /// Sets the Db2 archive logs.
+  /// </summary>
+  /// <param name="archiveLogs">The Db2 archive logs setting.</param>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithArchiveLogs(bool archiveLogs)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(archiveLogs: archiveLogs))
+        .WithEnvironment("ARCHIVE_LOGS", archiveLogs.ToString());
+  }
+
+  /// <summary>
+  /// Sets the Db2 autoconfig setting.
+  /// </summary>
+  /// <param name="autoConfig">The Db2 autoconfig setting.</param>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithAutoconfig(bool autoConfig)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(autoConfig: autoConfig))
+        .WithEnvironment("AUTOCONFIG", autoConfig.ToString());
+  }
+
+  /// <summary>
+  /// Accepts the Db2 license agreement.
+  /// </summary>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithLicenseAgreement()
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(licenseAgreement: DefaultLicenseAgreement))
+        .WithEnvironment("LICENSE", DefaultLicenseAgreement);
+  }
+
+  /// <summary>
+  /// Maps the database to memory.
+  /// </summary>
+  /// <returns>A configured instance of <see cref="Db2Builder" />.</returns>
+  public Db2Builder WithInMemoryDatabase()
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(licenseAgreement: DefaultInMemoryDatabasePath))
+        .WithTmpfsMount(DefaultInMemoryDatabasePath);
+  }
+
+  /// <inheritdoc />
+  public override Db2Container Build()
+  {
+    Validate();
+
+    // By default, the base builder waits until the container is running. However, for Db2, a more advanced waiting strategy is necessary 
+    // If the user does not provide a custom waiting strategy, append the default Db2 waiting strategy.
+    var db2Builder = DockerResourceConfiguration.WaitStrategies.Count() > 1
+      ? this
+      : WithWaitStrategy(Wait.ForUnixContainer()
+          .UntilMessageIsLogged("All databases are now active")
+          .UntilMessageIsLogged("Setup has completed.")
+          .AddCustomWaitStrategy(new WaitUntil(DockerResourceConfiguration))
+        );
+
+    return new Db2Container(db2Builder.DockerResourceConfiguration);
+  }
+
+  /// <inheritdoc />
+  protected override Db2Builder Init() => base.Init()
+        .WithImage(Db2Image)
+        .WithPortBinding(Db2Port, true)
+        .WithDatabase(DefaultDatabase)
+        .WithUsername(DefaultUsername)
+        .WithPassword(DefaultPassword)
+        .WithLicenseAgreement()
+        .WithArchiveLogs(false)
+        .WithAutoconfig(false)
+        .WithInMemoryDatabase()
+        .WithPrivileged(true);
+
+  /// <inheritdoc />
+  protected override void Validate()
+  {
+    base.Validate();
+
+    _ = Guard.Argument(DockerResourceConfiguration.Username, nameof(DockerResourceConfiguration.Username))
+        .NotNull()
+        .NotEmpty();
+
+    _ = Guard.Argument(DockerResourceConfiguration.Password, nameof(DockerResourceConfiguration.Password))
+        .NotNull()
+        .NotEmpty();
+  }
+
+  /// <inheritdoc />
+  protected override Db2Builder Clone(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(resourceConfiguration));
+  }
+
+  /// <inheritdoc />
+  protected override Db2Builder Clone(IContainerConfiguration resourceConfiguration)
+  {
+    return Merge(DockerResourceConfiguration, new Db2Configuration(resourceConfiguration));
+  }
+
+  /// <inheritdoc />
+  protected override Db2Builder Merge(Db2Configuration oldValue, Db2Configuration newValue)
+  {
+    return new Db2Builder(new Db2Configuration(oldValue, newValue));
+  }
+
+  /// <inheritdoc cref="IWaitUntil" />
+  private sealed class WaitUntil : IWaitUntil
+  {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WaitUntil" /> class.
+    /// </summary>
+    /// <param name="configuration">The container configuration.</param>
+    public WaitUntil(Db2Configuration configuration)
+    {
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> UntilAsync(IContainer container)
+    {
+      var db2Container = (Db2Container)container;
+
+      var execResult = await db2Container.ExecScriptAsync("SELECT 1 FROM SYSIBM.SYSDUMMY1").ConfigureAwait(false);
+
+      return 0L.Equals(execResult.ExitCode);
+    }
+  }
+}

src/Testcontainers.Db2/Db2Configuration.cs

@@ -0,0 +1,117 @@
+namespace Testcontainers.Db2;
+
+/// <inheritdoc cref="ContainerConfiguration" />
+[PublicAPI]
+public sealed class Db2Configuration : ContainerConfiguration
+{
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
+  /// </summary>
+  /// <param name="database">The Db2 database.</param>
+  /// <param name="username">The Db2 username.</param>
+  /// <param name="password">The Db2 password.</param>
+  /// <param name="archiveLogs">The Db2 archive logs setting.</param>
+  /// <param name="autoConfig">The Db2 auto config setting.</param>
+  /// <param name="licenseAgreement">The Db2 license agreement.</param>
+  /// <param name="inMemoryDatabasePath">The Db2 database path to map into memory (tmpfs).</param>
+  public Db2Configuration(
+        string database = null,
+        string username = null,
+        string password = null,
+        bool archiveLogs = false,
+        bool autoConfig = false,
+        string licenseAgreement = null,
+        string inMemoryDatabasePath = null)
+  {
+    Database = database;
+    Username = username;
+    Password = password;
+    ArchiveLogs = archiveLogs;
+    AutoConfig = autoConfig;
+    LicenseAgreement = licenseAgreement;
+    InMemoryDatabasePath = inMemoryDatabasePath;
+  }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
+  /// </summary>
+  /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+  public Db2Configuration(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+      : base(resourceConfiguration)
+  {
+    // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+  }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
+  /// </summary>
+  /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+  public Db2Configuration(IContainerConfiguration resourceConfiguration)
+      : base(resourceConfiguration)
+  {
+    // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+  }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
+  /// </summary>
+  /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+  public Db2Configuration(Db2Configuration resourceConfiguration)
+      : this(new Db2Configuration(), resourceConfiguration)
+  {
+    // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+  }
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="Db2Configuration" /> class.
+  /// </summary>
+  /// <param name="oldValue">The old Docker resource configuration.</param>
+  /// <param name="newValue">The new Docker resource configuration.</param>
+  public Db2Configuration(Db2Configuration oldValue, Db2Configuration newValue)
+      : base(oldValue, newValue)
+  {
+    Database = BuildConfiguration.Combine(oldValue.Database, newValue.Database);
+    Username = BuildConfiguration.Combine(oldValue.Username, newValue.Username);
+    Password = BuildConfiguration.Combine(oldValue.Password, newValue.Password);
+    ArchiveLogs = BuildConfiguration.Combine(oldValue.ArchiveLogs, newValue.ArchiveLogs);
+    AutoConfig = BuildConfiguration.Combine(oldValue.AutoConfig, newValue.AutoConfig);
+    LicenseAgreement = BuildConfiguration.Combine(oldValue.LicenseAgreement, newValue.LicenseAgreement);
+    InMemoryDatabasePath = BuildConfiguration.Combine(oldValue.InMemoryDatabasePath, newValue.InMemoryDatabasePath);
+  }
+
+  /// <summary>
+  /// Gets the Db2 database.
+  /// </summary>
+  public string Database { get; }
+
+  /// <summary>
+  /// Gets the Db2 username.
+  /// </summary>
+  public string Username { get; }
+
+  /// <summary>
+  /// Gets the Db2 password.
+  /// </summary>
+  public string Password { get; }
+
+  /// <summary>
+  /// Toggle for archivation of logs.
+  /// </summary>
+  public bool ArchiveLogs { get; }
+
+  /// <summary>
+  /// Toggle for database autoconfiguration.
+  /// </summary>
+  public bool AutoConfig { get; }
+
+  /// <summary>
+  /// License agreement value.
+  /// </summary>
+  public string LicenseAgreement { get; }
+
+  /// <summary>
+  /// Path to the database files that should be mapped into memory (tmpfs).
+  /// </summary>
+  public string InMemoryDatabasePath { get; }
+}