@@ -322,12 +344,12 @@
net.sourceforge.pmd
pmd-core
- 7.25.0
+ 7.26.0
net.sourceforge.pmd
pmd-java
- 7.25.0
+ 7.26.0
diff --git a/base/src/main/java/software/xdev/tci/concurrent/Suppliers.java b/base/src/main/java/software/xdev/tci/concurrent/Suppliers.java
new file mode 100644
index 00000000..c1780e63
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/concurrent/Suppliers.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.concurrent;
+
+import java.util.Objects;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Supplier;
+
+
+/**
+ * Based on
+ *
+ * Guava Supplier
+ *
+ * and minimized.
+ */
+public final class Suppliers
+{
+ private Suppliers()
+ {
+ }
+
+ /**
+ * Returns a supplier which caches the instance retrieved during the first call to {@code get()} and returns that
+ * value on subsequent calls to {@code get()}. See: memoization
+ *
+ * The returned supplier is thread-safe. The delegate's {@code get()} method will be invoked at
+ * most once unless the underlying {@code get()} throws an exception. The supplier's serialized form does not
+ * contain the cached value, which will be recalculated when {@code get()} is called on the deserialized instance.
+ *
+ *
When the underlying delegate throws an exception then this memoizing supplier will keep
+ * delegating calls until it returns valid data.
+ *
+ *
If {@code delegate} is an instance created by an earlier call to {@code memoize}, it is
+ * returned directly.
+ */
+ public static Supplier memoize(final Supplier delegate)
+ {
+ if(delegate instanceof NonSerializableMemoizingSupplier)
+ {
+ return delegate;
+ }
+ return new NonSerializableMemoizingSupplier<>(delegate);
+ }
+
+ @SuppressWarnings("java:S3077")
+ static class NonSerializableMemoizingSupplier implements Supplier
+ {
+ private final ReentrantLock lock = new ReentrantLock();
+
+ @SuppressWarnings("UnnecessaryLambda") // Must be a fixed singleton object
+ private static final Supplier SUCCESSFULLY_COMPUTED =
+ () -> {
+ throw new IllegalStateException(); // Should never get called.
+ };
+
+ @SuppressWarnings("PMD.AvoidUsingVolatile")
+ private volatile Supplier delegate;
+ // "value" does not need to be volatile; visibility piggy-backs on volatile read of "delegate".
+ private T value;
+
+ NonSerializableMemoizingSupplier(final Supplier delegate)
+ {
+ this.delegate = Objects.requireNonNull(delegate);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked") // Cast from Supplier to Supplier is always valid
+ public T get()
+ {
+ // Because Supplier is read-heavy, we use the "double-checked locking" pattern.
+ if(this.delegate != SUCCESSFULLY_COMPUTED)
+ {
+ this.lock.lock();
+ try
+ {
+ if(this.delegate != SUCCESSFULLY_COMPUTED)
+ {
+ final T t = this.delegate.get();
+ this.value = t;
+ this.delegate = (Supplier)SUCCESSFULLY_COMPUTED;
+ return t;
+ }
+ }
+ finally
+ {
+ this.lock.unlock();
+ }
+ }
+ // This is safe because we checked `delegate`.
+ return this.value;
+ }
+
+ @Override
+ public String toString()
+ {
+ final Supplier currentDelegate = this.delegate;
+ return "Suppliers.memoize("
+ + (currentDelegate == SUCCESSFULLY_COMPUTED
+ ? ""
+ : currentDelegate)
+ + ")";
+ }
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/config/DefaultConfig.java b/base/src/main/java/software/xdev/tci/config/DefaultConfig.java
index e8d3dcd0..38cf75d7 100644
--- a/base/src/main/java/software/xdev/tci/config/DefaultConfig.java
+++ b/base/src/main/java/software/xdev/tci/config/DefaultConfig.java
@@ -20,6 +20,8 @@
import java.util.function.IntSupplier;
import java.util.function.LongSupplier;
+import org.slf4j.LoggerFactory;
+
public abstract class DefaultConfig
{
@@ -27,7 +29,11 @@ public abstract class DefaultConfig
protected Optional resolve(final String propertyName)
{
- final String fullPropertyName = this.propertyNamePrefix() + "." + propertyName;
+ return this.resolveFullyBuildPropertyName(this.propertyNamePrefix() + "." + propertyName);
+ }
+
+ protected Optional resolveFullyBuildPropertyName(final String fullPropertyName)
+ {
return Optional.ofNullable(System.getenv(fullPropertyName
.replace(".", "_")
.toUpperCase(Locale.ROOT)))
@@ -36,11 +42,16 @@ protected Optional resolve(final String propertyName)
protected boolean resolveBool(final String propertyName, final boolean defaultVal)
{
- return this.resolve(propertyName)
- .map(s -> "1".equals(s) || Boolean.parseBoolean(s))
+ return this.resolveBool(propertyName)
.orElse(defaultVal);
}
+ protected Optional resolveBool(final String propertyName)
+ {
+ return this.resolve(propertyName)
+ .map(s -> "1".equals(s) || Boolean.parseBoolean(s));
+ }
+
protected int resolveInt(final String propertyName, final int defaultVal)
{
return this.resolveInt(propertyName, () -> defaultVal);
@@ -77,4 +88,18 @@ protected long resolveLong(final String propertyName, final LongSupplier default
})
.orElseGet(defaultValueSupplier::getAsLong);
}
+
+ protected T reportLegacyConfigOption(final String legacy, final String upToDate, final T value)
+ {
+ this.reportLegacyConfigOption(legacy, upToDate);
+ return value;
+ }
+
+ protected void reportLegacyConfigOption(final String legacy, final String upToDate)
+ {
+ LoggerFactory.getLogger(this.getClass()).warn(
+ "Detected deprecated config option that will be removed: {} - use {} instead",
+ legacy,
+ upToDate);
+ }
}
diff --git a/base/src/main/java/software/xdev/tci/factory/prestart/PreStartableTCIFactory.java b/base/src/main/java/software/xdev/tci/factory/prestart/PreStartableTCIFactory.java
index ea2bc211..b9329f28 100644
--- a/base/src/main/java/software/xdev/tci/factory/prestart/PreStartableTCIFactory.java
+++ b/base/src/main/java/software/xdev/tci/factory/prestart/PreStartableTCIFactory.java
@@ -150,7 +150,7 @@ public class PreStartableTCIFactory, I extends TCI
/**
* Has the following effects:
*
- * -Dinfra-pre-start.keep-ready=2
- * -Dinfra-pre-start.coordinator.idle-cpu-percent=50
+ * -Dtci.infra-pre-start.keep-ready=2
+ * -Dtci.infra-pre-start.coordinator.idle-cpu-percent=50
*
*
*/
@@ -90,7 +90,20 @@ public DefaultPreStartConfig()
@Override
public String propertyNamePrefix()
{
- return "infra-pre-start";
+ return "tci.infra-pre-start";
+ }
+
+ @Override
+ protected Optional resolve(final String propertyName)
+ {
+ return super.resolve(propertyName)
+ .or(() -> this.resolveFullyBuildPropertyName("infra-prestart." + propertyName)
+ .map(v -> this.reportLegacyConfigOption(
+ "infra-prestart." + propertyName,
+ this.propertyNamePrefix() + "." + propertyName,
+ v)
+ )
+ );
}
@Override
diff --git a/base/src/main/java/software/xdev/tci/factory/registry/DefaultTCIFactoryRegistry.java b/base/src/main/java/software/xdev/tci/factory/registry/DefaultTCIFactoryRegistry.java
index c5380c44..95b0658f 100644
--- a/base/src/main/java/software/xdev/tci/factory/registry/DefaultTCIFactoryRegistry.java
+++ b/base/src/main/java/software/xdev/tci/factory/registry/DefaultTCIFactoryRegistry.java
@@ -21,6 +21,9 @@
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import java.util.function.Function;
import java.util.stream.Collectors;
@@ -58,7 +61,28 @@ public void warmUp()
.filter(f -> !this.warmedUpFactories.contains(f))
.map(this::warmUpFactory)
.toList()
- .forEach(CompletableFuture::join);
+ .forEach(this::waitForWarmUpCF);
+ }
+ }
+
+ protected void waitForWarmUpCF(final CompletableFuture cf)
+ {
+ try
+ {
+ cf.get(10, TimeUnit.MINUTES);
+ }
+ catch(final TimeoutException ex)
+ {
+ throw new IllegalStateException("Timed out", ex);
+ }
+ catch(final InterruptedException ex)
+ {
+ Thread.currentThread().interrupt();
+ throw new IllegalStateException("Got interrupted", ex);
+ }
+ catch(final ExecutionException ex)
+ {
+ throw new IllegalStateException("Execution failed", ex);
}
}
diff --git a/base/src/main/java/software/xdev/tci/leakdetection/config/DefaultLeakDetectionConfig.java b/base/src/main/java/software/xdev/tci/leakdetection/config/DefaultLeakDetectionConfig.java
index a6664d55..c827642f 100644
--- a/base/src/main/java/software/xdev/tci/leakdetection/config/DefaultLeakDetectionConfig.java
+++ b/base/src/main/java/software/xdev/tci/leakdetection/config/DefaultLeakDetectionConfig.java
@@ -35,7 +35,7 @@ public DefaultLeakDetectionConfig()
@Override
protected String propertyNamePrefix()
{
- return "leak-detection";
+ return "tci.leak-detection";
}
@Override
diff --git a/base/src/main/java/software/xdev/tci/safestart/SafeNamedContainerStarter.java b/base/src/main/java/software/xdev/tci/safestart/SafeNamedContainerStarter.java
index 6f800b68..36d8d753 100644
--- a/base/src/main/java/software/xdev/tci/safestart/SafeNamedContainerStarter.java
+++ b/base/src/main/java/software/xdev/tci/safestart/SafeNamedContainerStarter.java
@@ -30,6 +30,8 @@
import org.testcontainers.DockerClientFactory;
import org.testcontainers.containers.GenericContainer;
+import com.github.dockerjava.api.exception.NotFoundException;
+
import software.xdev.tci.envperf.EnvironmentPerformance;
@@ -144,6 +146,15 @@ protected void tryCleanupContainerAfterStartFail(final List containerNam
}
catch(final Exception ex)
{
+ // Check if container was already cleaned up (e.g. with tryStart->stop)
+ if(ex.getCause() instanceof final NotFoundException nfe
+ && nfe.getMessage() != null
+ && nfe.getMessage().startsWith("Status 404: {\"message\":\"No such container:"))
+ {
+ LOG.info("Container[name='{}'] was already removed", containerName);
+ return;
+ }
+
LOG.warn("Unable to cleanup container[name='{}']", containerName, ex);
}
}
diff --git a/base/src/main/java/software/xdev/tci/serviceloading/TCIServiceLoader.java b/base/src/main/java/software/xdev/tci/serviceloading/TCIServiceLoader.java
index 891a9156..45c8047f 100644
--- a/base/src/main/java/software/xdev/tci/serviceloading/TCIServiceLoader.java
+++ b/base/src/main/java/software/xdev/tci/serviceloading/TCIServiceLoader.java
@@ -24,6 +24,9 @@
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
* Central point for service loading
@@ -31,6 +34,8 @@
@SuppressWarnings({"java:S6548", "java:S2789"}) // Don't force us to write our own Optional!?!
public class TCIServiceLoader
{
+ private static final Logger LOG = LoggerFactory.getLogger(TCIServiceLoader.class);
+
protected final Object globalInitServiceLockHandlerLock = new Object();
protected final InheritableThreadLocal>> tlDetectRecursiveInitServices =
new InheritableThreadLocal<>();
@@ -84,9 +89,12 @@ protected void initService(final Class clazz)
lock = this.servicesLoadingSyncLocks.computeIfAbsent(
clazz,
ignored -> new ReentrantLock());
- lock.lock();
+ this.reportLockAction("got", clazz);
}
+ lock.lock();
+ this.reportLockAction("acquired", clazz);
+
try
{
// Already initialized?
@@ -97,6 +105,11 @@ protected void initService(final Class clazz)
this.loadedServices.put(clazz, this.loadService(clazz));
}
+ catch(final RuntimeException rex)
+ {
+ LOG.debug("Service loading failed", rex);
+ throw rex;
+ }
finally
{
synchronized(this.globalInitServiceLockHandlerLock)
@@ -106,10 +119,24 @@ protected void initService(final Class clazz)
this.servicesLoadingSyncLocks.remove(clazz);
lock.unlock();
+ this.reportLockAction("release", clazz);
}
}
}
+ protected void reportLockAction(final String action, final Class clazz)
+ {
+ if(LOG.isTraceEnabled())
+ {
+ LOG.trace(
+ "Lock {} {} - T:{}",
+ action,
+ clazz,
+ Thread.currentThread().getName(),
+ new RuntimeException());
+ }
+ }
+
protected Optional loadService(final Class clazz)
{
return ServiceLoader.load(clazz)
diff --git a/base/src/main/java/software/xdev/tci/startup/error/java/fatal/HsErrPidStartUpCrashReporter.java b/base/src/main/java/software/xdev/tci/startup/error/java/fatal/HsErrPidStartUpCrashReporter.java
new file mode 100644
index 00000000..89fca3c7
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/error/java/fatal/HsErrPidStartUpCrashReporter.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.error.java.fatal;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.function.Supplier;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.io.IOUtils;
+import org.slf4j.Logger;
+import org.testcontainers.containers.GenericContainer;
+
+import software.xdev.tci.concurrent.Suppliers;
+
+
+/**
+ * Utility to log contents of java hs_err_pid files of a container that failed to start.
+ *
+ * Additionally also copies the file into target/has_err_pid/<containerId>/<hs_err_pid-file>
+ *
+ */
+public class HsErrPidStartUpCrashReporter
+{
+ protected static final String HS_ERR_PID = "hs_err_pid";
+ protected static final Supplier DEFAULT_HS_ERR_PID_EXTRACTION_PATTERN_SUPPLIER =
+ Suppliers.memoize(() -> Pattern.compile("^# (\\S{1,999}hs_err_pid\\d{1,9}\\.log)$", Pattern.MULTILINE));
+
+ protected final GenericContainer container;
+ protected final String hsErrPidSearchKey;
+ protected final Supplier hsErrPidExtractionPattern;
+ protected Supplier hsErrPidPathSupplier = Suppliers.memoize(
+ () -> Paths.get("target/has_err_pid"));
+
+ protected boolean startedWithoutCrashing;
+
+ public HsErrPidStartUpCrashReporter(final GenericContainer container)
+ {
+ this(container, HS_ERR_PID, DEFAULT_HS_ERR_PID_EXTRACTION_PATTERN_SUPPLIER);
+ }
+
+ protected HsErrPidStartUpCrashReporter(
+ final GenericContainer container,
+ final String hsErrPidSearchKey,
+ final Supplier hsErrPidExtractionPattern)
+ {
+ this.container = container;
+ this.hsErrPidSearchKey = hsErrPidSearchKey;
+ this.hsErrPidExtractionPattern = hsErrPidExtractionPattern;
+ }
+
+ public void containerIsStarted()
+ {
+ this.startedWithoutCrashing = true;
+ }
+
+ public void containerIsStopping(final Logger logger)
+ {
+ if(this.startedWithoutCrashing || !logger.isWarnEnabled())
+ {
+ return;
+ }
+
+ final String logs = this.container.getLogs();
+ if(!logs.contains(this.hsErrPidSearchKey))
+ {
+ return;
+ }
+
+ final Matcher matcher = this.hsErrPidExtractionPattern.get().matcher(logs);
+ if(!matcher.find())
+ {
+ logger.warn(
+ "Detected {} in log output but was unable to determine the file location - "
+ + "No regex match", this.hsErrPidSearchKey);
+ return;
+ }
+
+ final String filePath = matcher.group(1);
+ if(filePath == null || filePath.isBlank())
+ {
+ logger.warn(
+ "Detected {} in log output but was unable to determine the file location - "
+ + "No regex group match", this.hsErrPidSearchKey);
+ return;
+ }
+
+ try
+ {
+ final String containerId = this.container.getContainerId();
+
+ final Path hsErrPidContainerDirPath = this.hsErrPidPathSupplier.get().resolve(containerId);
+ Files.createDirectories(hsErrPidContainerDirPath);
+ final Path targetHsErrPidFilePath =
+ hsErrPidContainerDirPath.resolve(Path.of(filePath).getFileName().toString());
+
+ this.container.copyFileFromContainer(
+ filePath,
+ is -> Files.copy(
+ is,
+ targetHsErrPidFilePath,
+ StandardCopyOption.REPLACE_EXISTING));
+
+ logger.warn(
+ "Detected {} file[container={}]: {} -> {} \n{}",
+ this.hsErrPidSearchKey,
+ containerId,
+ filePath,
+ targetHsErrPidFilePath,
+ this.container.copyFileFromContainer(
+ filePath,
+ is -> IOUtils.toString(is, StandardCharsets.UTF_8)));
+ }
+ catch(final Exception ex)
+ {
+ logger.warn("Failed to read {} file {}", this.hsErrPidSearchKey, filePath, ex);
+ }
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/AbortMonitor.java b/base/src/main/java/software/xdev/tci/startup/wait/AbortMonitor.java
new file mode 100644
index 00000000..08723082
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/AbortMonitor.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+
+/**
+ * Monitor that holds the state if a WaitStrategy should be aborted
+ */
+public class AbortMonitor
+{
+ private final AtomicReference abortEx = new AtomicReference<>();
+
+ public void trigger(final RuntimeException rex)
+ {
+ this.abortEx.compareAndSet(null, rex);
+ }
+
+ public void throwIfRequired()
+ {
+ if(this.shouldAbort())
+ {
+ throw this.abortEx.get();
+ }
+ }
+
+ public boolean shouldAbort()
+ {
+ return this.abortEx.get() != null;
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/FastAbortOnContainerDeathWaitStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/FastAbortOnContainerDeathWaitStrategy.java
new file mode 100644
index 00000000..694be3e7
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/FastAbortOnContainerDeathWaitStrategy.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+import org.rnorth.ducttape.ratelimits.RateLimiter;
+import org.rnorth.ducttape.ratelimits.RateLimiterBuilder;
+import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
+import org.testcontainers.containers.wait.strategy.WaitStrategy;
+
+import software.xdev.tci.concurrent.ExecutorServiceCreatorHolder;
+import software.xdev.tci.startup.wait.holder.AbortableStrategyValues;
+import software.xdev.tci.startup.wait.holder.AbortableStrategyValuesHolder;
+import software.xdev.tci.startup.wait.strategy.AbstractWaitAbortableStrategy;
+import software.xdev.tci.startup.wait.strategy.WaitAllAbortableStrategy;
+
+
+/**
+ * A "wrapper" strategy that causes a fast-abort when the container dies.
+ *
+ * This is helpful when the container dies during the startup phase as the default wait-strategies
+ * would wait for the timeout to expire which can take up to a few minutes.
+ *
+ */
+public class FastAbortOnContainerDeathWaitStrategy extends AbstractWaitStrategy
+{
+ protected static final ExecutorService DEFAULT_EXECUTOR =
+ ExecutorServiceCreatorHolder.instance().createUnlimited("TCI-testcontainers-wait");
+
+ protected static final RateLimiter DEFAULT_RATE_LIMITER = RateLimiterBuilder
+ .newBuilder()
+ .withRate(10, TimeUnit.MINUTES)
+ .withConstantThroughput()
+ .build();
+
+ protected final WaitStrategy waitStrategy;
+ protected final ExecutorService executor;
+
+ public FastAbortOnContainerDeathWaitStrategy(final AbstractWaitAbortableStrategy waitStrategy)
+ {
+ this((WaitStrategy)waitStrategy);
+ }
+
+ /**
+ * @apiNote It's recommended to use {@link #FastAbortOnContainerDeathWaitStrategy(AbstractWaitAbortableStrategy)}
+ */
+ public FastAbortOnContainerDeathWaitStrategy(final WaitStrategy waitStrategy)
+ {
+ this(waitStrategy, DEFAULT_EXECUTOR);
+ }
+
+ protected FastAbortOnContainerDeathWaitStrategy(
+ final WaitStrategy waitStrategy,
+ final ExecutorService executor)
+ {
+ this.waitStrategy = waitStrategy;
+ this.executor = executor;
+
+ this.withRateLimiter(DEFAULT_RATE_LIMITER);
+ }
+
+ @Override
+ protected void waitUntilReady()
+ {
+ final AbortMonitor abortMonitor = new AbortMonitor();
+ final CompletableFuture cfWaitStrategy = CompletableFuture.runAsync(
+ () -> AbortableStrategyValuesHolder.executeWith(
+ () -> this.waitStrategy.waitUntilReady(this.waitStrategyTarget),
+ new AbortableStrategyValues(abortMonitor, this.executor)),
+ this.executor
+ );
+
+ final CompletableFuture cfContainerDeathWatchDog = CompletableFuture.runAsync(
+ () -> this.runCheckIfContainerIsDead(abortMonitor, cfWaitStrategy),
+ this.executor
+ );
+
+ try
+ {
+ CompletableFuture.anyOf(cfWaitStrategy, cfContainerDeathWatchDog).join();
+ }
+ finally
+ {
+ abortMonitor.trigger(new CancellationException("Completed"));
+ }
+ }
+
+ @SuppressWarnings("java:S5411") // Irrelevant here!
+ protected void runCheckIfContainerIsDead(
+ final AbortMonitor abortMonitor,
+ final CompletableFuture cfWaitStrategy)
+ {
+ while(!abortMonitor.shouldAbort() && !cfWaitStrategy.isDone())
+ {
+ if(!this.rateLimiterWhenReadyExceptionless(this::isContainerAlive))
+ {
+ final IllegalStateException abortEx = new IllegalStateException(
+ "Container " + this.waitStrategyTarget.getContainerId() + " is dead - Aborting");
+ abortMonitor.trigger(abortEx);
+ throw abortEx;
+ }
+ }
+ }
+
+ @SuppressWarnings("PMD.PreserveStackTrace")
+ protected T rateLimiterWhenReadyExceptionless(final Supplier supplier)
+ {
+ try
+ {
+ return this.getRateLimiter().getWhenReady(supplier::get);
+ }
+ catch(final Exception ex)
+ {
+ if(ex instanceof final RuntimeException rex)
+ {
+ throw rex;
+ }
+ throw new RuntimeException(ex);
+ }
+ }
+
+ protected boolean isContainerAlive()
+ {
+ return Optional.ofNullable(this.waitStrategyTarget.getCurrentContainerInfo().getState())
+ .filter(s -> Boolean.TRUE.equals(s.getRunning())
+ || Boolean.TRUE.equals(s.getPaused()))
+ .isPresent();
+ }
+
+ @Override
+ public WaitStrategy withStartupTimeout(final Duration startupTimeout)
+ {
+ this.waitStrategy.withStartupTimeout(startupTimeout);
+ return this;
+ }
+
+ /**
+ * Creates a new instance with {@link WaitAllAbortableStrategy} as inner strategy and allows configuring it.
+ */
+ public static FastAbortOnContainerDeathWaitStrategy waitAll(
+ final UnaryOperator configure)
+ {
+ return new FastAbortOnContainerDeathWaitStrategy(configure.apply(new WaitAllAbortableStrategy()));
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValues.java b/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValues.java
new file mode 100644
index 00000000..97f5f2a3
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValues.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.holder;
+
+import java.util.concurrent.ExecutorService;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+
+
+public record AbortableStrategyValues(
+ AbortMonitor abortMonitor,
+ ExecutorService executor
+)
+{
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java b/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java
new file mode 100644
index 00000000..92f57a23
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.holder;
+
+/**
+ * @apiNote Please note that this is the Java 21 version. The Java 25 version uses ScopedValues.
+ */
+public final class AbortableStrategyValuesHolder
+{
+ private static final ThreadLocal TL = new ThreadLocal<>();
+
+ public static void executeWith(final Runnable runnable, final AbortableStrategyValues values)
+ {
+ TL.set(values);
+ try
+ {
+ runnable.run();
+ }
+ finally
+ {
+ TL.remove();
+ }
+ }
+
+ public static AbortableStrategyValues get()
+ {
+ return TL.get();
+ }
+
+ private AbortableStrategyValuesHolder()
+ {
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/strategy/AbstractWaitAbortableStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/strategy/AbstractWaitAbortableStrategy.java
new file mode 100644
index 00000000..5dd0be68
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/strategy/AbstractWaitAbortableStrategy.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.strategy;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import org.rnorth.ducttape.unreliables.Unreliables;
+import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+import software.xdev.tci.startup.wait.holder.AbortableStrategyValuesHolder;
+
+
+public abstract class AbstractWaitAbortableStrategy>
+ extends AbstractWaitStrategy
+{
+ protected T startupRetryUntilSuccess(final Callable callable)
+ {
+ return Unreliables.retryUntilSuccess(
+ (int)this.startupTimeout.getSeconds(),
+ TimeUnit.SECONDS,
+ callable
+ );
+ }
+
+ protected void startupRetryUntilSuccessWithRateLimitWhenNotAborted(
+ final AbortMonitor abortMonitor,
+ final Runnable runnable)
+ {
+ this.startupRetryUntilSuccess(() -> {
+ if(!abortMonitor.shouldAbort())
+ {
+ this.getRateLimiter().doWhenReady(runnable);
+ }
+ return true;
+ });
+ }
+
+ @Override
+ protected void waitUntilReady()
+ {
+ this.waitUntilReady(AbortableStrategyValuesHolder.get().abortMonitor());
+ }
+
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
+ {
+ // NOOP
+ }
+
+ protected ExecutorService getExecutor()
+ {
+ return AbortableStrategyValuesHolder.get().executor();
+ }
+
+ @SuppressWarnings("unchecked")
+ protected S self()
+ {
+ return (S)this;
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/strategy/HostPortWaitAbortableStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/strategy/HostPortWaitAbortableStrategy.java
new file mode 100644
index 00000000..49b79e61
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/strategy/HostPortWaitAbortableStrategy.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.strategy;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.ContainerLaunchException;
+import org.testcontainers.containers.wait.internal.ExternalPortListeningCheck;
+import org.testcontainers.containers.wait.internal.InternalCommandPortListeningCheck;
+import org.testcontainers.shaded.org.awaitility.Awaitility;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+
+
+/**
+ * Based on {@link org.testcontainers.containers.wait.strategy.HostPortWaitStrategy}
+ */
+public class HostPortWaitAbortableStrategy extends AbstractWaitAbortableStrategy
+{
+ private static final Logger LOG = LoggerFactory.getLogger(HostPortWaitAbortableStrategy.class);
+
+ protected int[] ports;
+
+ @Override
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
+ {
+ final Set externalLivenessCheckPorts = this.determineExternalLivenessCheckPorts();
+ if(externalLivenessCheckPorts == null || externalLivenessCheckPorts.isEmpty())
+ {
+ if(LOG.isDebugEnabled())
+ {
+ LOG.debug(
+ "Liveness check ports of {} is empty. Not waiting.",
+ this.waitStrategyTarget.getContainerInfo().getName()
+ );
+ }
+ return;
+ }
+
+ abortMonitor.throwIfRequired();
+
+ final Set internalPorts = this.getInternalPorts(
+ externalLivenessCheckPorts,
+ this.waitStrategyTarget.getExposedPorts());
+
+ final Callable internalCheck = this.createInternalCheck(internalPorts);
+ final Callable externalCheck = this.createExternalCheck(externalLivenessCheckPorts);
+
+ try
+ {
+ final List> futures = this.getExecutor().invokeAll(
+ Arrays.asList(
+ // Blocking
+ () -> {
+ final long startMs = System.currentTimeMillis();
+ final Boolean result = internalCheck.call();
+ LOG.debug(
+ "Internal port check {} for {} took {}ms",
+ Boolean.TRUE.equals(result) ? "passed" : "failed",
+ internalPorts,
+ System.currentTimeMillis() - startMs
+ );
+ return result;
+ },
+ // Polling
+ () -> {
+ final long startMs = System.currentTimeMillis();
+ Awaitility.await()
+ .pollInSameThread()
+ .pollInterval(Duration.ofMillis(100))
+ .pollDelay(Duration.ZERO)
+ .failFast(
+ "container is no longer running",
+ () -> !this.waitStrategyTarget.isRunning() || abortMonitor.shouldAbort())
+ .ignoreExceptions()
+ .forever()
+ .until(externalCheck);
+
+ LOG.debug(
+ "External port check passed for {} mapped as {} took {}ms",
+ internalPorts,
+ externalLivenessCheckPorts,
+ System.currentTimeMillis() - startMs
+ );
+ return true;
+ }
+ ),
+ this.startupTimeout.getSeconds(),
+ TimeUnit.SECONDS
+ );
+
+ for(final Future future : futures)
+ {
+ future.get(0, TimeUnit.SECONDS);
+ }
+ }
+ catch(final InterruptedException iex)
+ {
+ Thread.currentThread().interrupt();
+ throw new IllegalStateException("Got interrupted", iex);
+ }
+ catch(final CancellationException | ExecutionException | TimeoutException e)
+ {
+ throw new ContainerLaunchException(
+ "Timed out waiting for container port to open ("
+ + this.waitStrategyTarget.getHost()
+ + " ports: "
+ + externalLivenessCheckPorts
+ + " should be listening)",
+ e
+ );
+ }
+ }
+
+ private ExternalPortListeningCheck createExternalCheck(final Set externalLivenessCheckPorts)
+ {
+ return new ExternalPortListeningCheck(
+ this.waitStrategyTarget,
+ externalLivenessCheckPorts
+ );
+ }
+
+ private InternalCommandPortListeningCheck createInternalCheck(final Set internalPorts)
+ {
+ return new InternalCommandPortListeningCheck(this.waitStrategyTarget, internalPorts);
+ }
+
+ /**
+ * @apiNote Can return null
+ */
+ protected Set determineExternalLivenessCheckPorts()
+ {
+ if(this.ports == null || this.ports.length == 0)
+ {
+ return this.getLivenessCheckPorts();
+ }
+
+ return Arrays
+ .stream(this.ports)
+ .mapToObj(this.waitStrategyTarget::getMappedPort)
+ .collect(Collectors.toSet());
+ }
+
+ protected Set getInternalPorts(
+ final Set externalLivenessCheckPorts,
+ final List exposedPorts)
+ {
+ return exposedPorts
+ .stream()
+ .filter(port -> externalLivenessCheckPorts.contains(this.waitStrategyTarget.getMappedPort(port)))
+ .collect(Collectors.toSet());
+ }
+
+ public HostPortWaitAbortableStrategy forPorts(final int... ports)
+ {
+ this.ports = ports;
+ return this.self();
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/strategy/HttpWaitAbortableStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/strategy/HttpWaitAbortableStrategy.java
new file mode 100644
index 00000000..42e951ad
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/strategy/HttpWaitAbortableStrategy.java
@@ -0,0 +1,524 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.strategy;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UncheckedIOException;
+import java.net.HttpURLConnection;
+import java.net.Socket;
+import java.net.URI;
+import java.net.URL;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509ExtendedTrustManager;
+
+import org.rnorth.ducttape.TimeoutException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.ContainerLaunchException;
+import org.testcontainers.shaded.com.google.common.io.BaseEncoding;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+
+
+/**
+ * Based on {@link org.testcontainers.containers.wait.strategy.HttpWaitStrategy}
+ */
+@SuppressWarnings("PMD.GodClass")
+public class HttpWaitAbortableStrategy extends AbstractWaitAbortableStrategy
+{
+ private static final Logger LOG = LoggerFactory.getLogger(HttpWaitAbortableStrategy.class);
+
+ /**
+ * Authorization HTTP header.
+ */
+ protected static final String HEADER_AUTHORIZATION = "Authorization";
+
+ /**
+ * Basic Authorization scheme prefix.
+ */
+ protected static final String AUTH_BASIC = "Basic ";
+
+ protected String path = "/";
+
+ protected String method = "GET";
+
+ protected final Set statusCodes = new HashSet<>();
+
+ protected boolean tlsEnabled;
+
+ protected String username;
+
+ protected String password;
+
+ protected final Map headers = new HashMap<>();
+
+ protected Predicate responsePredicate;
+
+ protected Predicate statusCodePredicate;
+
+ protected Optional livenessPort = Optional.empty();
+
+ protected Duration readTimeout = Duration.ofSeconds(1);
+
+ protected boolean allowInsecure;
+
+ // region Configure
+
+ /**
+ * Waits for the given status code.
+ *
+ * @param statusCode the expected status code
+ * @return this
+ */
+ public HttpWaitAbortableStrategy forStatusCode(final int statusCode)
+ {
+ this.statusCodes.add(statusCode);
+ return this.self();
+ }
+
+ /**
+ * Waits for the status code to pass the given predicate
+ *
+ * @param statusCodePredicate The predicate to test the response against
+ * @return this
+ */
+ public HttpWaitAbortableStrategy forStatusCodeMatching(final Predicate statusCodePredicate)
+ {
+ this.statusCodePredicate = statusCodePredicate;
+ return this;
+ }
+
+ /**
+ * Waits for the given path.
+ *
+ * @param path the path to check
+ * @return this
+ */
+ public HttpWaitAbortableStrategy forPath(final String path)
+ {
+ this.path = path;
+ return this.self();
+ }
+
+ /**
+ * Wait for the given port.
+ *
+ * @param port the given port
+ * @return this
+ */
+ public HttpWaitAbortableStrategy forPort(final int port)
+ {
+ this.livenessPort = Optional.of(port);
+ return this.self();
+ }
+
+ /**
+ * Indicates that the status check should use HTTPS.
+ *
+ * @return this
+ */
+ public HttpWaitAbortableStrategy usingTls()
+ {
+ this.tlsEnabled = true;
+ return this.self();
+ }
+
+ /**
+ * Indicates the HTTP method to use (GET by default).
+ *
+ * @param method the HTTP method.
+ * @return this
+ */
+ public HttpWaitAbortableStrategy withMethod(final String method)
+ {
+ this.method = method;
+ return this.self();
+ }
+
+ /**
+ * Indicates that HTTPS connection could use untrusted (self signed) certificate chains.
+ *
+ * @return this
+ */
+ public HttpWaitAbortableStrategy allowInsecure()
+ {
+ this.allowInsecure = true;
+ return this.self();
+ }
+
+ /**
+ * Authenticate with HTTP Basic Authorization credentials.
+ *
+ * @param username the username
+ * @param password the password
+ * @return this
+ */
+ public HttpWaitAbortableStrategy withBasicCredentials(
+ final String username,
+ final String password)
+ {
+ this.username = username;
+ this.password = password;
+ return this.self();
+ }
+
+ /**
+ * Add a custom HTTP Header to the call.
+ *
+ * @param name The HTTP Header name
+ * @param value The HTTP Header value
+ * @return this
+ */
+ public HttpWaitAbortableStrategy withHeader(
+ final String name,
+ final String value)
+ {
+ this.headers.put(name, value);
+ return this.self();
+ }
+
+ /**
+ * Add multiple custom HTTP Headers to the call.
+ *
+ * @param headers Headers map of name/value
+ * @return this
+ */
+ public HttpWaitAbortableStrategy withHeaders(final Map headers)
+ {
+ this.headers.putAll(headers);
+ return this.self();
+ }
+
+ /**
+ * Set the HTTP connections read timeout.
+ *
+ * @param timeout the timeout (minimum 1 millisecond)
+ * @return this
+ */
+ public HttpWaitAbortableStrategy withReadTimeout(final Duration timeout)
+ {
+ if(timeout.toMillis() < 1)
+ {
+ throw new IllegalArgumentException("you cannot specify a value smaller than 1 ms");
+ }
+ this.readTimeout = timeout;
+ return this.self();
+ }
+
+ /**
+ * Waits for the response to pass the given predicate
+ *
+ * @param responsePredicate The predicate to test the response against
+ * @return this
+ */
+ public HttpWaitAbortableStrategy forResponsePredicate(final Predicate responsePredicate)
+ {
+ this.responsePredicate = responsePredicate;
+ return this.self();
+ }
+
+ // endregion
+
+ @Override
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
+ {
+ final String containerName = this.waitStrategyTarget.getContainerInfo().getName();
+
+ final Integer livenessCheckPort = this.livenessPort
+ .map(this.waitStrategyTarget::getMappedPort)
+ .orElseGet(() -> {
+ final Set livenessCheckPorts = this.getLivenessCheckPorts();
+ if(livenessCheckPorts == null || livenessCheckPorts.isEmpty())
+ {
+ LOG.warn("{}: No exposed ports or mapped ports - cannot wait for status", containerName);
+ return -1;
+ }
+ return livenessCheckPorts.iterator().next();
+ });
+
+ abortMonitor.throwIfRequired();
+
+ if(null == livenessCheckPort || -1 == livenessCheckPort)
+ {
+ return;
+ }
+ final URI rawUri = this.buildLivenessUri(livenessCheckPort);
+ final String uri = rawUri.toString();
+
+ try
+ {
+ // Un-map the port for logging
+ final int originalPort = this.waitStrategyTarget
+ .getExposedPorts()
+ .stream()
+ .filter(exposedPort -> rawUri.getPort() == this.waitStrategyTarget.getMappedPort(exposedPort))
+ .findFirst()
+ .orElseThrow(() -> new IllegalStateException("Target port " + rawUri.getPort() + " is not exposed"));
+ LOG.info(
+ "{}: Waiting for {} seconds for URL: {} (where port {} maps to container port {})",
+ containerName,
+ this.startupTimeout.getSeconds(),
+ uri,
+ rawUri.getPort(),
+ originalPort
+ );
+ }
+ catch(final RuntimeException e)
+ {
+ // do not allow a failure in logging to prevent progress, but log for diagnosis
+ LOG.warn("Unexpected error occurred - will proceed to try to wait anyway", e);
+ }
+
+ abortMonitor.throwIfRequired();
+
+ // try to connect to the URL
+ try
+ {
+ this.startupRetryUntilSuccessWithRateLimitWhenNotAborted(
+ abortMonitor,
+ () -> this.connectAndCheck(uri));
+ abortMonitor.throwIfRequired();
+ }
+ catch(final TimeoutException e)
+ {
+ throw new ContainerLaunchException(
+ String.format(
+ "Timed out waiting for URL to be accessible (%s should return HTTP %s)",
+ uri,
+ this.statusCodes.isEmpty() ? HttpURLConnection.HTTP_OK : this.statusCodes
+ ),
+ e
+ );
+ }
+ }
+
+ protected void connectAndCheck(final String uri)
+ {
+ try
+ {
+ final HttpURLConnection connection = this.openConnection(uri);
+ connection.setReadTimeout(Math.toIntExact(this.readTimeout.toMillis()));
+
+ // authenticate
+ if(this.username != null && !this.username.isEmpty())
+ {
+ connection.setRequestProperty(
+ HEADER_AUTHORIZATION,
+ this.buildAuthString(this.username, this.password)
+ );
+ connection.setUseCaches(false);
+ }
+
+ // Add user configured headers
+ this.headers.forEach(connection::setRequestProperty);
+ connection.setRequestMethod(this.method);
+ connection.connect();
+
+ LOG.trace("Get response code {}", connection.getResponseCode());
+
+ // Choose the statusCodePredicate strategy depending on what we defined.
+ if(!this.determineStatusCodePredicate().test(connection.getResponseCode()))
+ {
+ throw new IllegalStateException("HTTP response code was: " + connection.getResponseCode());
+ }
+
+ if(this.responsePredicate != null)
+ {
+ final String responseBody = this.getResponseBody(connection);
+
+ LOG.trace("Got response {}", responseBody);
+
+ if(!this.responsePredicate.test(responseBody))
+ {
+ throw new IllegalStateException("Response: " + responseBody + " did not match predicate");
+ }
+ }
+ }
+ catch(final IOException e)
+ {
+ throw new UncheckedIOException(e);
+ }
+ }
+
+ private Predicate determineStatusCodePredicate()
+ {
+ if(this.statusCodes.isEmpty() && this.statusCodePredicate == null)
+ {
+ // We have no status code and no predicate so we expect a 200 OK response code
+ return responseCode -> HttpURLConnection.HTTP_OK == responseCode;
+ }
+ else if(!this.statusCodes.isEmpty() && this.statusCodePredicate == null)
+ {
+ // We use the default status predicate checker when we only have status codes
+ return this.statusCodes::contains;
+ }
+ else if(this.statusCodes.isEmpty())
+ {
+ // We only have a predicate
+ return this.statusCodePredicate;
+ }
+
+ // We have both predicate and status code
+ return this.statusCodePredicate.or(this.statusCodes::contains);
+ }
+
+ protected HttpURLConnection openConnection(final String uri) throws IOException
+ {
+ if(!this.tlsEnabled)
+ {
+ return (HttpURLConnection)new URL(uri).openConnection();
+ }
+
+ final HttpsURLConnection connection = (HttpsURLConnection)new URL(uri).openConnection();
+ if(this.allowInsecure)
+ {
+ // Create a trust manager that does not validate certificate chains
+ // and trust all certificates
+ final TrustManager[] trustAllCerts = new TrustManager[]{
+ new X509ExtendedTrustManager()
+ {
+ @Override
+ public X509Certificate[] getAcceptedIssuers()
+ {
+ return new X509Certificate[0];
+ }
+
+ @Override
+ public void checkClientTrusted(final X509Certificate[] certs, final String authType)
+ {
+ }
+
+ @Override
+ public void checkServerTrusted(final X509Certificate[] certs, final String authType)
+ {
+ }
+
+ @Override
+ public void checkClientTrusted(
+ final X509Certificate[] chain,
+ final String authType,
+ final Socket socket)
+ {
+ }
+
+ @Override
+ public void checkServerTrusted(
+ final X509Certificate[] chain,
+ final String authType,
+ final Socket socket)
+ {
+ }
+
+ @Override
+ public void checkClientTrusted(
+ final X509Certificate[] chain,
+ final String authType,
+ final SSLEngine engine)
+ {
+ }
+
+ @Override
+ public void checkServerTrusted(
+ final X509Certificate[] chain,
+ final String authType,
+ final SSLEngine engine)
+ {
+ }
+ },
+ };
+
+ try
+ {
+ // Create custom SSL context and set the "trust all certificates" trust manager
+ final SSLContext sc = SSLContext.getInstance("SSL");
+ sc.init(new KeyManager[0], trustAllCerts, new SecureRandom());
+ connection.setSSLSocketFactory(sc.getSocketFactory());
+ }
+ catch(final NoSuchAlgorithmException | KeyManagementException ex)
+ {
+ throw new IOException("Unable to create custom SSL factory instance", ex);
+ }
+ }
+
+ return connection;
+ }
+
+ /**
+ * Build the URI on which to check if the container is ready.
+ *
+ * @param livenessCheckPort the liveness port
+ * @return the liveness URI
+ */
+ @SuppressWarnings("checkstyle:MagicNumber")
+ protected URI buildLivenessUri(final int livenessCheckPort)
+ {
+ final String scheme = (this.tlsEnabled ? "https" : "http") + "://";
+ final String host = this.waitStrategyTarget.getHost();
+
+ final String portSuffix =
+ this.tlsEnabled && livenessCheckPort == 443
+ || !this.tlsEnabled && livenessCheckPort == 80
+ ? ""
+ : ":" + livenessCheckPort;
+
+ return URI.create(scheme + host + portSuffix + this.path);
+ }
+
+ /**
+ * @param username the username
+ * @param password the password
+ * @return a basic authentication string for the given credentials
+ */
+ protected String buildAuthString(final String username, final String password)
+ {
+ return AUTH_BASIC + BaseEncoding.base64().encode((username + ":" + password).getBytes());
+ }
+
+ @SuppressWarnings({"PMD.AvoidStringBuilderOrBuffer", "checkstyle:MagicNumber"})
+ protected String getResponseBody(final HttpURLConnection connection) throws IOException
+ {
+ final BufferedReader reader = new BufferedReader(new InputStreamReader(
+ connection.getResponseCode() >= 200 && connection.getResponseCode() < 300
+ ? connection.getInputStream()
+ : connection.getErrorStream()));
+
+ final StringBuilder builder = new StringBuilder();
+ String line;
+ while((line = reader.readLine()) != null)
+ {
+ builder.append(line);
+ }
+ return builder.toString();
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/strategy/LogMessageWaitAbortableStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/strategy/LogMessageWaitAbortableStrategy.java
new file mode 100644
index 00000000..651d6ee9
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/strategy/LogMessageWaitAbortableStrategy.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.strategy;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Predicate;
+
+import org.testcontainers.containers.ContainerLaunchException;
+import org.testcontainers.containers.output.FrameConsumerResultCallback;
+import org.testcontainers.containers.output.OutputFrame;
+import org.testcontainers.containers.output.WaitingConsumer;
+
+import com.github.dockerjava.api.command.LogContainerCmd;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+
+
+/**
+ * Based on {@link org.testcontainers.containers.wait.strategy.LogMessageWaitStrategy}
+ */
+public class LogMessageWaitAbortableStrategy extends AbstractWaitAbortableStrategy
+{
+ protected String regEx;
+
+ protected int times = 1;
+
+ @Override
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
+ {
+ try(final LogContainerCmd cmd = this.waitStrategyTarget
+ .getDockerClient()
+ .logContainerCmd(this.waitStrategyTarget.getContainerId())
+ .withFollowStream(true)
+ .withSince(0)
+ .withStdOut(true)
+ .withStdErr(true))
+ {
+ try(final FrameConsumerResultCallback callback = new FrameConsumerResultCallback())
+ {
+ final WaitingConsumer waitingConsumer = new WaitingConsumer();
+ callback.addConsumer(OutputFrame.OutputType.STDOUT, waitingConsumer);
+ callback.addConsumer(OutputFrame.OutputType.STDERR, waitingConsumer);
+
+ cmd.exec(callback);
+
+ final Predicate waitPredicate = outputFrame -> {
+ abortMonitor.throwIfRequired();
+
+ // (?s) enables line terminator matching (equivalent to Pattern.DOTALL)
+ return outputFrame.getUtf8String().matches("(?s)" + this.regEx);
+ };
+ try
+ {
+ waitingConsumer.waitUntil(
+ waitPredicate,
+ this.startupTimeout.getSeconds(),
+ TimeUnit.SECONDS,
+ this.times);
+ }
+ catch(final TimeoutException e)
+ {
+ throw new ContainerLaunchException(
+ "Timed out waiting for log output matching '" + this.regEx + "'",
+ e);
+ }
+ }
+ catch(final IOException ioe)
+ {
+ throw new UncheckedIOException(ioe);
+ }
+ }
+ }
+
+ public LogMessageWaitAbortableStrategy withRegEx(final String regEx)
+ {
+ this.regEx = regEx;
+ return this.self();
+ }
+
+ public LogMessageWaitAbortableStrategy withTimes(final int times)
+ {
+ this.times = times;
+ return this.self();
+ }
+}
diff --git a/base/src/main/java/software/xdev/tci/startup/wait/strategy/WaitAllAbortableStrategy.java b/base/src/main/java/software/xdev/tci/startup/wait/strategy/WaitAllAbortableStrategy.java
new file mode 100644
index 00000000..eb69606b
--- /dev/null
+++ b/base/src/main/java/software/xdev/tci/startup/wait/strategy/WaitAllAbortableStrategy.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright © 2024 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.tci.startup.wait.strategy;
+
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.rnorth.ducttape.timeouts.Timeouts;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.wait.strategy.WaitAllStrategy;
+import org.testcontainers.containers.wait.strategy.WaitStrategy;
+
+import software.xdev.tci.startup.wait.AbortMonitor;
+import software.xdev.tci.startup.wait.holder.AbortableStrategyValues;
+import software.xdev.tci.startup.wait.holder.AbortableStrategyValuesHolder;
+
+
+/**
+ * Based on {@link WaitAllStrategy}
+ */
+public class WaitAllAbortableStrategy extends AbstractWaitAbortableStrategy
+{
+ private static final Logger LOG = LoggerFactory.getLogger(WaitAllAbortableStrategy.class);
+
+ protected final WaitAllStrategy.Mode mode;
+
+ protected final List strategies = new ArrayList<>();
+
+ public WaitAllAbortableStrategy()
+ {
+ this(WaitAllStrategy.Mode.WITH_OUTER_TIMEOUT);
+ }
+
+ public WaitAllAbortableStrategy(final WaitAllStrategy.Mode mode)
+ {
+ this.mode = mode;
+ }
+
+ @Override
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
+ {
+ if(this.mode == WaitAllStrategy.Mode.WITH_INDIVIDUAL_TIMEOUTS_ONLY)
+ {
+ this.waitUntilNestedStrategiesAreReady(abortMonitor);
+ }
+ else
+ {
+ final AbortableStrategyValues valuesToPropagate = AbortableStrategyValuesHolder.get();
+ Timeouts.doWithTimeout(
+ (int)this.startupTimeout.toMillis(),
+ TimeUnit.MILLISECONDS,
+ () -> AbortableStrategyValuesHolder.executeWith(
+ () -> this.waitUntilNestedStrategiesAreReady(abortMonitor),
+ valuesToPropagate)
+ );
+ }
+ }
+
+ private void waitUntilNestedStrategiesAreReady(final AbortMonitor abortMonitor)
+ {
+ for(final WaitStrategy strategy : this.strategies)
+ {
+ abortMonitor.throwIfRequired();
+
+ final long startMs = System.currentTimeMillis();
+ LOG.debug("Waiting for {}", strategy);
+
+ strategy.waitUntilReady(this.waitStrategyTarget);
+
+ LOG.debug("Finished waiting for {}, took {}ms", strategy, System.currentTimeMillis() - startMs);
+ }
+ }
+
+ public WaitAllAbortableStrategy withStrategy(final AbstractWaitAbortableStrategy strategy)
+ {
+ return this.withWaitStrategy(strategy);
+ }
+
+ /**
+ * @apiNote It's recommended to use {@link #withStrategy(AbstractWaitAbortableStrategy)}
+ */
+ public WaitAllAbortableStrategy withWaitStrategy(final WaitStrategy strategy)
+ {
+ if(this.mode == WaitAllStrategy.Mode.WITH_OUTER_TIMEOUT)
+ {
+ this.applyStartupTimeout(strategy);
+ }
+
+ this.strategies.add(strategy);
+ return this.self();
+ }
+
+ @Override
+ public WaitAllAbortableStrategy withStartupTimeout(final Duration startupTimeout)
+ {
+ if(this.mode == WaitAllStrategy.Mode.WITH_INDIVIDUAL_TIMEOUTS_ONLY)
+ {
+ throw new IllegalStateException(
+ String.format(
+ "Changing startup timeout is not supported with mode %s",
+ WaitAllStrategy.Mode.WITH_INDIVIDUAL_TIMEOUTS_ONLY
+ )
+ );
+ }
+
+ super.withStartupTimeout(startupTimeout);
+
+ this.strategies.forEach(this::applyStartupTimeout);
+ return this.self();
+ }
+
+ private void applyStartupTimeout(final WaitStrategy childStrategy)
+ {
+ childStrategy.withStartupTimeout(this.startupTimeout);
+ }
+}
diff --git a/base/src/main/java25/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java b/base/src/main/java25/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java
new file mode 100644
index 00000000..d0c2b249
--- /dev/null
+++ b/base/src/main/java25/software/xdev/tci/startup/wait/holder/AbortableStrategyValuesHolder.java
@@ -0,0 +1,21 @@
+package software.xdev.tci.startup.wait.holder;
+
+
+public final class AbortableStrategyValuesHolder
+{
+ private static final ScopedValue SV = ScopedValue.newInstance();
+
+ public static void executeWith(final Runnable runnable, final AbortableStrategyValues values)
+ {
+ ScopedValue.where(SV, values).run(runnable);
+ }
+
+ public static AbortableStrategyValues get()
+ {
+ return SV.get();
+ }
+
+ private AbortableStrategyValuesHolder()
+ {
+ }
+}
diff --git a/bom/pom.xml b/bom/pom.xml
index de9df7dc..e373dffe 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -6,7 +6,7 @@
software.xdev.tci
bom
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
pom
bom
@@ -51,62 +51,72 @@
software.xdev.tci
base
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
db-jdbc
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
db-jdbc-spring-orm
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
db-jdbc-spring-orm-eclipselink
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
db-jdbc-spring-orm-hibernate
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
+
+
+ software.xdev.tci
+ image-build
+ 4.0.0-SNAPSHOT
software.xdev.tci
jacoco
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
jul-to-slf4j
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
junit-jupiter-api-support
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
+
+
+ software.xdev.tci
+ mailpit
+ 4.0.0-SNAPSHOT
software.xdev.tci
mockserver
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
oidc-server-mock
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
selenium
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
software.xdev.tci
spring-dao-support
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
diff --git a/db-jdbc-spring-orm-eclipselink/pom.xml b/db-jdbc-spring-orm-eclipselink/pom.xml
index 3508dd9e..16226b22 100644
--- a/db-jdbc-spring-orm-eclipselink/pom.xml
+++ b/db-jdbc-spring-orm-eclipselink/pom.xml
@@ -6,7 +6,7 @@
software.xdev.tci
db-jdbc-spring-orm-eclipselink
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
jar
db-jdbc-spring-orm-eclipselink
@@ -53,13 +53,13 @@
software.xdev.tci
db-jdbc-spring-orm
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
org.eclipse.persistence
eclipselink
- 5.0.0
+ 5.0.1
@@ -226,7 +226,7 @@
org.sonatype.central
central-publishing-maven-plugin
- 0.10.0
+ 0.11.0
true
sonatype-central-portal
@@ -248,7 +248,7 @@
com.puppycrawl.tools
checkstyle
- 13.5.0
+ 13.8.0
@@ -286,12 +286,12 @@
net.sourceforge.pmd
pmd-core
- 7.25.0
+ 7.26.0
net.sourceforge.pmd
pmd-java
- 7.25.0
+ 7.26.0
diff --git a/db-jdbc-spring-orm-eclipselink/src/main/java/software/xdev/tci/db/persistence/eclipselink/EclipseLinkEntityManagerControllerFactory.java b/db-jdbc-spring-orm-eclipselink/src/main/java/software/xdev/tci/db/persistence/eclipselink/EclipseLinkEntityManagerControllerFactory.java
index 7308aab3..a344b7da 100644
--- a/db-jdbc-spring-orm-eclipselink/src/main/java/software/xdev/tci/db/persistence/eclipselink/EclipseLinkEntityManagerControllerFactory.java
+++ b/db-jdbc-spring-orm-eclipselink/src/main/java/software/xdev/tci/db/persistence/eclipselink/EclipseLinkEntityManagerControllerFactory.java
@@ -19,9 +19,6 @@
import java.util.Set;
import java.util.function.Supplier;
-import jakarta.persistence.EntityManagerFactory;
-import jakarta.persistence.spi.PersistenceUnitInfo;
-
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.jpa.PersistenceProvider;
import org.springframework.orm.jpa.persistenceunit.SpringPersistenceUnitInfo;
@@ -30,7 +27,7 @@
public class EclipseLinkEntityManagerControllerFactory
- extends SpringEntityManagerControllerFactory
+ extends SpringEntityManagerControllerFactory
{
// Disabled (false) by default as it's not used by the default created SpringPersistenceUnitInfo anyway
protected boolean weavingEnabled;
@@ -69,7 +66,6 @@ protected SpringPersistenceUnitInfo createSpringPersistenceUnitInfo()
final SpringPersistenceUnitInfo spui = super.createSpringPersistenceUnitInfo();
// Required otherwise createContainerEntityManagerFactoryImpl crashes
spui.setPersistenceUnitRootUrl(this.getClass().getResource(""));
- spui.setPersistenceProviderClassName(PersistenceProvider.class.getName());
return spui;
}
@@ -85,10 +81,8 @@ protected Map buildProperties()
}
@Override
- protected EntityManagerFactory createEntityManagerFactory(
- final PersistenceUnitInfo pui,
- final Map properties)
+ protected PersistenceProvider createDefaultPersistenceProvider()
{
- return new PersistenceProvider().createContainerEntityManagerFactory(pui, properties);
+ return new PersistenceProvider();
}
}
diff --git a/db-jdbc-spring-orm-hibernate/pom.xml b/db-jdbc-spring-orm-hibernate/pom.xml
index 5d61a77c..9e11668f 100644
--- a/db-jdbc-spring-orm-hibernate/pom.xml
+++ b/db-jdbc-spring-orm-hibernate/pom.xml
@@ -6,7 +6,7 @@
software.xdev.tci
db-jdbc-spring-orm-hibernate
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
jar
db-jdbc-spring-orm-hibernate
@@ -53,24 +53,24 @@
software.xdev.tci
db-jdbc-spring-orm
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
org.hibernate.orm
hibernate-core
- 7.4.2.Final
+ 7.4.5.Final
org.hibernate.orm
hibernate-scan-jandex
- 7.4.2.Final
+ 7.4.5.Final
org.hibernate.orm
hibernate-hikaricp
- 7.4.2.Final
+ 7.4.5.Final
@@ -259,7 +259,7 @@
com.puppycrawl.tools
checkstyle
- 13.6.0
+ 13.8.0
@@ -297,12 +297,12 @@
net.sourceforge.pmd
pmd-core
- 7.25.0
+ 7.26.0
net.sourceforge.pmd
pmd-java
- 7.25.0
+ 7.26.0
diff --git a/db-jdbc-spring-orm-hibernate/src/main/java/software/xdev/tci/db/persistence/hibernate/HibernateEntityManagerControllerFactory.java b/db-jdbc-spring-orm-hibernate/src/main/java/software/xdev/tci/db/persistence/hibernate/HibernateEntityManagerControllerFactory.java
index 49fc9332..b2161daf 100644
--- a/db-jdbc-spring-orm-hibernate/src/main/java/software/xdev/tci/db/persistence/hibernate/HibernateEntityManagerControllerFactory.java
+++ b/db-jdbc-spring-orm-hibernate/src/main/java/software/xdev/tci/db/persistence/hibernate/HibernateEntityManagerControllerFactory.java
@@ -20,20 +20,16 @@
import java.util.Set;
import java.util.function.Supplier;
-import jakarta.persistence.EntityManagerFactory;
-import jakarta.persistence.spi.PersistenceUnitInfo;
-
import org.hibernate.cfg.JdbcSettings;
import org.hibernate.cfg.PersistenceSettings;
import org.hibernate.hikaricp.internal.HikariCPConnectionProvider;
import org.hibernate.jpa.HibernatePersistenceProvider;
-import org.springframework.orm.jpa.persistenceunit.SpringPersistenceUnitInfo;
import software.xdev.tci.db.persistence.SpringEntityManagerControllerFactory;
public class HibernateEntityManagerControllerFactory
- extends SpringEntityManagerControllerFactory
+ extends SpringEntityManagerControllerFactory
{
protected String connectionProviderClassName = HikariCPConnectionProvider.class.getName();
protected boolean disableHibernateFormatter = true;
@@ -69,14 +65,6 @@ public HibernateEntityManagerControllerFactory withUseCachingStandardScanner(
return this;
}
- @Override
- protected SpringPersistenceUnitInfo createSpringPersistenceUnitInfo()
- {
- final SpringPersistenceUnitInfo spui = super.createSpringPersistenceUnitInfo();
- spui.setPersistenceProviderClassName(HibernatePersistenceProvider.class.getName());
- return spui;
- }
-
@Override
protected Map buildProperties()
{
@@ -95,10 +83,8 @@ protected Map buildProperties()
}
@Override
- protected EntityManagerFactory createEntityManagerFactory(
- final PersistenceUnitInfo pui,
- final Map properties)
+ protected HibernatePersistenceProvider createDefaultPersistenceProvider()
{
- return new HibernatePersistenceProvider().createContainerEntityManagerFactory(pui, properties);
+ return new HibernatePersistenceProvider();
}
}
diff --git a/db-jdbc-spring-orm/pom.xml b/db-jdbc-spring-orm/pom.xml
index 30410169..fc5c488f 100644
--- a/db-jdbc-spring-orm/pom.xml
+++ b/db-jdbc-spring-orm/pom.xml
@@ -6,7 +6,7 @@
software.xdev.tci
db-jdbc-spring-orm
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
jar
db-jdbc-spring-orm
@@ -53,7 +53,7 @@
software.xdev.tci
db-jdbc
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
@@ -258,7 +258,7 @@
com.puppycrawl.tools
checkstyle
- 13.6.0
+ 13.8.0
@@ -295,12 +295,12 @@
net.sourceforge.pmd
pmd-core
- 7.25.0
+ 7.26.0
net.sourceforge.pmd
pmd-java
- 7.25.0
+ 7.26.0
diff --git a/db-jdbc-spring-orm/src/main/java/software/xdev/tci/db/persistence/SpringEntityManagerControllerFactory.java b/db-jdbc-spring-orm/src/main/java/software/xdev/tci/db/persistence/SpringEntityManagerControllerFactory.java
index 8231b06d..58d49639 100644
--- a/db-jdbc-spring-orm/src/main/java/software/xdev/tci/db/persistence/SpringEntityManagerControllerFactory.java
+++ b/db-jdbc-spring-orm/src/main/java/software/xdev/tci/db/persistence/SpringEntityManagerControllerFactory.java
@@ -20,21 +20,27 @@
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
+import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
+import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.PersistenceUnitTransactionType;
import jakarta.persistence.spi.ClassTransformer;
+import jakarta.persistence.spi.PersistenceProvider;
import jakarta.persistence.spi.PersistenceUnitInfo;
import org.springframework.orm.jpa.persistenceunit.SpringPersistenceUnitInfo;
@SuppressWarnings("java:S119")
-public abstract class SpringEntityManagerControllerFactory>
+public abstract class SpringEntityManagerControllerFactory<
+ P extends PersistenceProvider,
+ SELF extends SpringEntityManagerControllerFactory>
extends EntityManagerControllerFactory
{
protected boolean addJarFileUrls;
+ protected P persistenceProvider;
protected SpringEntityManagerControllerFactory()
{
@@ -61,6 +67,15 @@ public SELF withAddJarFileUrls(final boolean addJarFileUrls)
return this.self();
}
+ /**
+ * Allows to manually configure a (default) persistence provider
+ */
+ public SELF withPersistenceProvider(final P persistenceProvider)
+ {
+ this.persistenceProvider = persistenceProvider;
+ return this.self();
+ }
+
@SuppressWarnings("java:S4449") // can't add annotations to source code that we do not control
protected SpringPersistenceUnitInfo instantiateSpringPersistenceUnitInfo()
{
@@ -100,12 +115,6 @@ protected SpringPersistenceUnitInfo createSpringPersistenceUnitInfo()
return pui;
}
- @Override
- protected PersistenceUnitInfo createPersistenceUnitInfo()
- {
- return this.createSpringPersistenceUnitInfo().asStandardPersistenceUnitInfo();
- }
-
protected Collection jarFileUrlsToAdd()
{
try
@@ -119,4 +128,24 @@ protected Collection jarFileUrlsToAdd()
throw new UncheckedIOException(ioe);
}
}
+
+ @Override
+ protected PersistenceUnitInfo createPersistenceUnitInfo()
+ {
+ return this.createSpringPersistenceUnitInfo().asStandardPersistenceUnitInfo();
+ }
+
+ protected abstract P createDefaultPersistenceProvider();
+
+ @Override
+ protected EntityManagerFactory createEntityManagerFactory(
+ final PersistenceUnitInfo pui,
+ final Map properties)
+ {
+ if(this.persistenceProvider == null)
+ {
+ this.persistenceProvider = this.createDefaultPersistenceProvider();
+ }
+ return this.persistenceProvider.createContainerEntityManagerFactory(pui, properties);
+ }
}
diff --git a/db-jdbc/pom.xml b/db-jdbc/pom.xml
index 34598840..fb25db29 100644
--- a/db-jdbc/pom.xml
+++ b/db-jdbc/pom.xml
@@ -6,7 +6,7 @@
software.xdev.tci
db-jdbc
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
jar
db-jdbc
@@ -53,7 +53,7 @@
software.xdev.tci
base
- 3.4.2-SNAPSHOT
+ 4.0.0-SNAPSHOT
@@ -72,7 +72,7 @@
org.junit.jupiter
junit-jupiter
- 6.1.0
+ 6.1.2
test
@@ -268,7 +268,7 @@
com.puppycrawl.tools
checkstyle
- 13.6.0
+ 13.8.0
@@ -306,12 +306,12 @@
net.sourceforge.pmd
pmd-core
- 7.25.0
+ 7.26.0
net.sourceforge.pmd
pmd-java
- 7.25.0
+ 7.26.0
diff --git a/db-jdbc/src/main/java/software/xdev/tci/db/containers/WaitableJDBCContainer.java b/db-jdbc/src/main/java/software/xdev/tci/db/containers/WaitableJDBCContainer.java
index 2decd1cf..62ca1a55 100644
--- a/db-jdbc/src/main/java/software/xdev/tci/db/containers/WaitableJDBCContainer.java
+++ b/db-jdbc/src/main/java/software/xdev/tci/db/containers/WaitableJDBCContainer.java
@@ -16,22 +16,22 @@
package software.xdev.tci.db.containers;
import java.sql.Connection;
+import java.sql.SQLException;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
-import org.rnorth.ducttape.TimeoutException;
import org.rnorth.ducttape.ratelimits.RateLimiter;
import org.rnorth.ducttape.ratelimits.RateLimiterBuilder;
import org.rnorth.ducttape.unreliables.Unreliables;
-import org.testcontainers.containers.ContainerLaunchException;
import org.testcontainers.containers.JdbcDatabaseContainer;
-import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
-import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.containers.wait.strategy.WaitAllStrategy;
import org.testcontainers.containers.wait.strategy.WaitStrategy;
import org.testcontainers.containers.wait.strategy.WaitStrategyTarget;
import software.xdev.tci.envperf.EnvironmentPerformance;
+import software.xdev.tci.startup.wait.AbortMonitor;
+import software.xdev.tci.startup.wait.FastAbortOnContainerDeathWaitStrategy;
+import software.xdev.tci.startup.wait.strategy.AbstractWaitAbortableStrategy;
+import software.xdev.tci.startup.wait.strategy.HostPortWaitAbortableStrategy;
public interface WaitableJDBCContainer extends WaitStrategyTarget
@@ -39,10 +39,11 @@ public interface WaitableJDBCContainer extends WaitStrategyTarget
@SuppressWarnings("checkstyle:MagicNumber")
default WaitStrategy completeJDBCWaitStrategy()
{
- return new WaitAllStrategy()
- .withStrategy(Wait.defaultWaitStrategy())
+ return FastAbortOnContainerDeathWaitStrategy.waitAll(s -> s
+ .withStartupTimeout(Duration.ofSeconds(40L + EnvironmentPerformance.cpuSlownessFactor() * 20L))
+ .withStrategy(new HostPortWaitAbortableStrategy())
.withStrategy(new JDBCWaitStrategy())
- .withStartupTimeout(Duration.ofSeconds(40L + EnvironmentPerformance.cpuSlownessFactor() * 20L));
+ );
}
WaitStrategy getWaitStrategy();
@@ -59,20 +60,19 @@ default void waitUntilContainerStarted()
/**
* @apiNote Assumes that the container is already started
*/
- class JDBCWaitStrategy extends AbstractWaitStrategy
+ class JDBCWaitStrategy extends AbstractWaitAbortableStrategy
{
@SuppressWarnings("checkstyle:MagicNumber")
public JDBCWaitStrategy()
{
this.withRateLimiter(RateLimiterBuilder.newBuilder()
- .withRate(200, TimeUnit.MILLISECONDS)
+ .withRate(5, TimeUnit.SECONDS)
.withConstantThroughput()
.build());
}
- @SuppressWarnings("PMD.PreserveStackTrace")
@Override
- protected void waitUntilReady()
+ protected void waitUntilReady(final AbortMonitor abortMonitor)
{
if(!(this.waitStrategyTarget instanceof final JdbcDatabaseContainer container))
{
@@ -80,45 +80,33 @@ protected void waitUntilReady()
"Container must implement JdbcDatabaseContainer and WaitableJDBCContainer");
}
- try
- {
- this.waitUntilJDBCValid(container);
- }
- catch(final TimeoutException e)
- {
- throw new ContainerLaunchException(
- "JDBCContainer cannot be accessed by (JDBC URL: "
- + container.getJdbcUrl()
- + "), please check container logs");
- }
- }
-
- protected void waitUntilJDBCValid(final JdbcDatabaseContainer container)
- {
- Unreliables.retryUntilTrue(
- (int)this.startupTimeout.getSeconds(),
- TimeUnit.SECONDS,
- // Rate limit creation of connections as this is quite an expensive operation
- () -> this.getRateLimiter().getWhenReady(() -> {
+ // Rate limit creation of connections as this is quite an expensive operation
+ this.startupRetryUntilSuccessWithRateLimitWhenNotAborted(
+ abortMonitor,
+ () -> {
try(final Connection connection = container.createConnection(""))
{
- return this.waitUntilJDBCConnectionValidated(container, connection);
+ this.waitUntilJDBCConnectionValidated(container, connection);
+ }
+ catch(final SQLException sqlEx)
+ {
+ throw new IllegalStateException("SQL failed", sqlEx);
}
- })
+ }
);
}
@SuppressWarnings({"unused", "checkstyle:MagicNumber"}) // Parameter might be used by extension
- protected boolean waitUntilJDBCConnectionValidated(
+ protected void waitUntilJDBCConnectionValidated(
final JdbcDatabaseContainer container,
final Connection connection)
{
final RateLimiter validateJDBCRateLimiter = RateLimiterBuilder.newBuilder()
- .withRate(50, TimeUnit.MILLISECONDS)
+ .withRate(20, TimeUnit.SECONDS)
.withConstantThroughput()
.build();
- return Unreliables.retryUntilSuccess(
+ Unreliables.retryUntilSuccess(
// If this fails after startupTimeout / 2 (min=3s, max=30s)
// it might be possible that the connection is somehow corrupted or broken
// -> Build a new connection after that (see waitUntilJDBCValid)
diff --git a/image-build/README.md b/image-build/README.md
new file mode 100644
index 00000000..2430e99d
--- /dev/null
+++ b/image-build/README.md
@@ -0,0 +1,36 @@
+# Image-Build
+
+Provides common utility and configuration to build images.
+
+## Config
+
+The configuration is dynamically loaded from (sorted by highest priority)
+
+* Environment variables
+ * prefixed with `TCI_IMAGE-BUILD__`
+ * where `imageName` is the (sanitized) name of the image to build
+ * prefixed with `TCI_IMAGE-BUILD_`
+ * all properties are in UPPERCASE and use `_` instead of `.` or `-`
+* System properties
+ * prefixed with `tci.image-build..`
+ * where `imageName` is the (sanitized) name of the image to build
+ * prefixed with `tci.image-build.`
+
+_NOTE: Sanitized image-names only include alphanumeric characters, `_` or `-`. All other characters are replaced by `_`_
+
+Full list of configuration options
+
+| Property | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `delete-on-exit` | `bool` | `false` | Should the image be deleted on exit? |
+| `logger-for-build-prefix` | `string` | `container.build.` | Prefix used for the build logger |
+| `cache-from` | `string` | - | Only applies to BuildKit (native) build.
See [Docker docs](https://docs.docker.com/build/cache/backends/) for details. |
+| `cache-to` | `string` | - | Only applies to BuildKit (native) build.
See [Docker docs](https://docs.docker.com/build/cache/backends/) for details. |
+| `save-cache-in-background` | `bool` | if `cache-to` set `true`
otherwise `false` | Builds the image the first time WITHOUT `cache-to` and the async in the background again WITH `cache-to`. This way saving the cache does not delay test execution. |
+| `wait-for-save-cache-in-background` | `bool` | `true` | Wait until all caches are saved before terminating |
+
+
Please have a look at the [advanced-demo](../advanced-demo/) and the corresponding [GitHub Actions workflow](../.github/workflows/run-integration-tests.yml) for details.
-### Example Report
+## Config
+
+The configuration is dynamically loaded from (sorted by highest priority)
+
+* Environment variables
+ * prefixed with `TCI_JACOCO_`
+ * all properties are in UPPERCASE and use `_` instead of `.` or `-`
+* System properties
+ * prefixed with `tci.jacoco.`
+
+Full list of configuration options
+
+| Property | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `enabled` | `bool` | `false` | You should probably set this to `true` |
+| `execution-data-files-dir` | `string` | `target/jacoco-execution-data-files` | Location where the jacoco execution reports/execution data files are stored |
+| `move-old-execution-data-files-dir` | `bool` | `true` | If `execution-data-files-dir` already exists it will be moved to `execution-data-files-dir-old` |
+| `execution-data-files-dir-old` | `string` | `target/jacoco-execution-data-files-old` | Location where previous jacoco execution reports/execution data files are moved to. If the directory already exists it will be deleted. |
+| `execution-data-file-suffix` | `string` | `-jacoco.exec` | Suffix for the jacoco reports/execution data files |
+
+The configuration is dynamically loaded from (sorted by highest priority)
+
+* Environment variables
+ * prefixed with `TCI_SELENIUM_`
+ * all properties are in UPPERCASE and use `_` instead of `.` or `-`
+* System properties
+ * prefixed with `tci.selenium.`
+
+Full list of configuration options
+
+| Property | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `record-mode` | `Enum` | `RECORD_FAILING` | Recording mode.
Available:- SKIP - Do not record any videos
- RECORD_ALL - Record all tests
- RECORD_FAILING - Record failing tests only
|
+| `dir-for-records` | `String` | `target/records` | Directory for storing the recorded videos |
+| `vnc-enabled` | `bool` | `false` | Enable [VNC](https://en.wikipedia.org/wiki/VNC) and [NoVNC](https://github.com/novnc/novnc). This is usually only needed during debugging. |
+| `bidi-enabled` | `bool` | `true` | Use [Selenium BiDirectional functionality](https://www.selenium.dev/documentation/webdriver/bidi/) instead of legacy Chrome DevTools Protocol (CDP).
Disabling this will make certain operations unavailable e.g. listening for browser logs. |
+| `deactivate-cdp-if-possible` | `bool` | `true` | Disable Chrome DevTools Protocol (CDP) if possible.
CDP requires additional maven dependencies (e.g. `selenium-devtools-v137)` that are not present by default and will result in a warning. |
+| `min-browser-console-log-level` | `Enum` | `ERROR` | Prints out browser console logs. Configures the MINIMUM log level.
Available options:
+
+