Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(rds): refresh backend endpoints after container restarts (#6090)

joão pedro britodb76a5e5fda5
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java
index a646a7cf44..6cc40f387f 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java
@@ -1097,7 +1097,7 @@ public class ContainerLifecycleManager {
*/
public EndpointInfo resolveEndpoint(String containerId, int containerPort) {
InspectContainerResponse inspect = dockerClient.inspectContainerCmd(containerId).exec();
- return resolveEndpoint(inspect, containerPort);
+ return resolveEndpoint(inspect, containerPort, null, true);
}
/**
@@ -1109,7 +1109,7 @@ public class ContainerLifecycleManager {
*/
public EndpointInfo resolveEndpoint(String containerId, int containerPort, String preferredNetwork) {
InspectContainerResponse inspect = dockerClient.inspectContainerCmd(containerId).exec();
- return resolveEndpoint(inspect, containerPort, preferredNetwork);
+ return resolveEndpoint(inspect, containerPort, preferredNetwork, true);
}
/**
@@ -1492,7 +1492,13 @@ public class ContainerLifecycleManager {
return resolveEndpoint(inspect, containerPort, null);
}
- private EndpointInfo resolveEndpoint(InspectContainerResponse inspect, int containerPort, String preferredNetwork) {
+ private EndpointInfo resolveEndpoint(InspectContainerResponse inspect, int containerPort,
+ String preferredNetwork) {
+ return resolveEndpoint(inspect, containerPort, preferredNetwork, false);
+ }
+
+ private EndpointInfo resolveEndpoint(InspectContainerResponse inspect, int containerPort,
+ String preferredNetwork, boolean requireReachable) {
if (!containerDetector.isRunningInContainer()) {
// Native mode: use localhost and the bound host port
Map<ExposedPort, Ports.Binding[]> bindings = inspect.getNetworkSettings().getPorts().getBindings();
@@ -1502,11 +1508,19 @@ public class ContainerLifecycleManager {
int hostPort = Integer.parseInt(binding[0].getHostPortSpec());
return new EndpointInfo("localhost", hostPort);
}
- // Fallback to container port
+ if (requireReachable) {
+ throw new IllegalStateException(
+ "Container " + inspect.getId() + " has no published binding for port " + containerPort);
+ }
+ // Creation can still expose an internal-only port to another container.
return new EndpointInfo("localhost", containerPort);
- } else {
- return new EndpointInfo(resolveReachableHost(inspect, preferredNetwork), containerPort);
}
+ String host = resolveReachableHost(inspect, preferredNetwork);
+ if (requireReachable && (host == null || host.isBlank())) {
+ throw new IllegalStateException(
+ "Container " + inspect.getId() + " has no reachable address for port " + containerPort);
+ }
+ return new EndpointInfo(host, containerPort);
}
private String resolveReachableHost(InspectContainerResponse inspect, String preferredNetwork) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
index f2a725eef4..79fc2ccf19 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
@@ -903,15 +903,17 @@ public class RdsService implements Resettable, ResourceProvider {
if (!mock && hasBackend(backendHost, backendPort)) {
final String instanceRegion = regionFromArn(instance.getDbInstanceArn());
+ InstanceBackendIdentity backendIdentity = instanceBackendIdentity(instance);
try {
proxyManager.startProxy(rdsResourceRelayKey(instance.getDbInstanceArn(), id),
+ backendIdentity.runtimeId(),
engine, iamEnabled, proxyPort, backendHost, backendPort,
instance.getEndpoint().address(),
instance.getMasterUsername(), instance.getMasterPassword(), dbName,
(user, pw) -> validateDbPasswordForScope(
accountId, instanceRegion, id, user, pw),
proxyBinding(engine, instance.getEndpoint().address(), instance.getEndpoint().port(),
- instanceRegion, accountId, dbUserResourceId(instance)));
+ instanceRegion, accountId, backendIdentity.dbUserResourceId()));
} catch (RuntimeException | Error e) {
try {
deleteInstanceForScope(accountId, effectiveRegion, id);
@@ -3572,6 +3574,7 @@ public class RdsService implements Resettable, ResourceProvider {
final String accountId = accountIdFromArn(instance.getDbInstanceArn());
final String instanceRegion = regionFromArn(instance.getDbInstanceArn());
proxyManager.startProxy(rdsResourceRelayKey(instance.getDbInstanceArn(), id),
+ instanceBackendIdentity(instance).runtimeId(),
instance.getEngine(),
instance.isIamDatabaseAuthenticationEnabled(),
instance.getProxyPort(), instance.getContainerHost(), instance.getContainerPort(),
@@ -3752,6 +3755,7 @@ public class RdsService implements Resettable, ResourceProvider {
final String accountId = accountIdFromArn(cluster.getDbClusterArn());
final String clusterRegion = regionFromArn(cluster.getDbClusterArn());
proxyManager.startProxy(rdsResourceRelayKey(cluster.getDbClusterArn(), id),
+ cluster.getDbClusterArn(),
cluster.getEngine(), cluster.isIamDatabaseAuthenticationEnabled(), cluster.getProxyPort(),
handle.getHost(), handle.getPort(), cluster.getEndpoint().address(),
cluster.getMasterUsername() != null ? cluster.getMasterUsername() : "root",
@@ -3820,7 +3824,9 @@ public class RdsService implements Resettable, ResourceProvider {
? instance.getMasterUsername() : "root";
final String accountId = accountIdFromArn(instance.getDbInstanceArn());
final String instanceRegion = regionFromArn(instance.getDbInstanceArn());
+ InstanceBackendIdentity backendIdentity = instanceBackendIdentity(instance);
proxyManager.startProxy(rdsResourceRelayKey(instance.getDbInstanceArn(), id),
+ backendIdentity.runtimeId(),
instance.getEngine(),
instance.isIamDatabaseAuthenticationEnabled(),
instance.getProxyPort(), instance.getContainerHost(), instance.getContainerPort(),
@@ -3829,7 +3835,8 @@ public class RdsService implements Resettable, ResourceProvider {
(user, pw) -> validateDbPasswordForScope(
accountId, instanceRegion, id, user, pw),
proxyBinding(instance.getEngine(), instance.getEndpoint().address(),
- instance.getEndpoint().port(), instanceRegion, accountId, dbUserResourceId(instance)));
+ instance.getEndpoint().port(), instanceRegion, accountId,
+ backendIdentity.dbUserResourceId()));
} else {
// No backing container: created or last rebooted while no daemon was reachable.
instance = doEnsureInstanceBackend(id, effectiveRegion);
@@ -3840,18 +3847,22 @@ public class RdsService implements Resettable, ResourceProvider {
return instance;
}
- private String dbUserResourceId(DbInstance instance) {
+ private InstanceBackendIdentity instanceBackendIdentity(DbInstance instance) {
String clusterId = instance.getDbClusterIdentifier();
if (clusterId != null && !clusterId.isBlank()) {
DbCluster cluster = findClusterForScope(accountIdFromArn(instance.getDbInstanceArn()),
regionFromArn(instance.getDbInstanceArn()), clusterId);
if (cluster != null) {
- return cluster.getDbClusterResourceId();
+ return new InstanceBackendIdentity(
+ cluster.getDbClusterArn(), cluster.getDbClusterResourceId());
}
}
- return instance.getDbiResourceId();
+ return new InstanceBackendIdentity(
+ instance.getDbInstanceArn(), instance.getDbiResourceId());
}
+ private record InstanceBackendIdentity(String runtimeId, String dbUserResourceId) {}
+
/**
* The binding the proxy validates IAM auth tokens against. As on RDS a token is good for the
* endpoint it was generated for (hostname, port and region); MySQL and MariaDB proxies always
@@ -3937,6 +3948,7 @@ public class RdsService implements Resettable, ResourceProvider {
? instance.getMasterUsername() : "root";
final String accountId = accountIdFromArn(instance.getDbInstanceArn());
final String instanceRegion = regionFromArn(instance.getDbInstanceArn());
+ InstanceBackendIdentity backendIdentity = instanceBackendIdentity(instance);
int relayPort = instance.getProxyPort();
DbEndpoint relayEndpoint = instance.getEndpoint();
boolean allocatedRelayPort = false;
@@ -3947,13 +3959,15 @@ public class RdsService implements Resettable, ResourceProvider {
relayEndpoint = proxyEndpoint(relayPort);
}
proxyManager.startProxy(rdsResourceRelayKey(instance.getDbInstanceArn(), id),
+ backendIdentity.runtimeId(),
instance.getEngine(), instance.isIamDatabaseAuthenticationEnabled(),
relayPort, backendHost, backendPort, relayEndpoint.address(),
effectiveMasterUser, instance.getMasterPassword(), instance.getDbName(),
(user, pw) -> validateDbPasswordForScope(
accountId, instanceRegion, id, user, pw),
proxyBinding(instance.getEngine(), relayEndpoint.address(),
- relayEndpoint.port(), instanceRegion, accountId, dbUserResourceId(instance)));
+ relayEndpoint.port(), instanceRegion, accountId,
+ backendIdentity.dbUserResourceId()));
} catch (RuntimeException e) {
if (allocatedRelayPort) {
releaseProxyPort(relayPort);
@@ -4045,6 +4059,7 @@ public class RdsService implements Resettable, ResourceProvider {
relayEndpoint = proxyEndpoint(relayPort);
}
proxyManager.startProxy(rdsResourceRelayKey(cluster.getDbClusterArn(), id),
+ cluster.getDbClusterArn(),
cluster.getEngine(), cluster.isIamDatabaseAuthenticationEnabled(),
relayPort, started.getHost(), started.getPort(), relayEndpoint.address(),
effectiveMasterUser, cluster.getMasterPassword(), cluster.getDatabaseName(),
@@ -4481,6 +4496,7 @@ public class RdsService implements Resettable, ResourceProvider {
final String accountId = accountIdFromArn(cluster.getDbClusterArn());
final String clusterRegion = regionFromArn(cluster.getDbClusterArn());
proxyManager.startProxy(rdsResourceRelayKey(cluster.getDbClusterArn(), id),
+ cluster.getDbClusterArn(),
engine, iamEnabled, proxyPort,
cluster.getContainerHost(), cluster.getContainerPort(),
cluster.getEndpoint().address(),
@@ -5890,6 +5906,7 @@ public class RdsService implements Resettable, ResourceProvider {
String backendHost;
int backendPort;
+ String backendRuntimeId;
DatabaseEngine engine;
String masterUser;
String masterPassword;
@@ -5911,6 +5928,7 @@ public class RdsService implements Resettable, ResourceProvider {
effectiveRegion, "DB cluster", clusterId);
backendHost = cluster.getContainerHost();
backendPort = cluster.getContainerPort();
+ backendRuntimeId = cluster.getDbClusterArn();
engine = cluster.getEngine();
masterUser = cluster.getMasterUsername();
masterPassword = cluster.getMasterPassword();
@@ -5931,6 +5949,7 @@ public class RdsService implements Resettable, ResourceProvider {
effectiveRegion, "DB instance", instanceId);
backendHost = instance.getContainerHost();
backendPort = instance.getContainerPort();
+ backendRuntimeId = instanceBackendIdentity(instance).runtimeId();
engine = instance.getEngine();
masterUser = instance.getMasterUsername();
masterPassword = instance.getMasterPassword();
@@ -5982,7 +6001,7 @@ public class RdsService implements Resettable, ResourceProvider {
final String targetId = target.getRdsResourceId();
final boolean isCluster = "TRACKED_CLUSTER".equals(target.getType());
final String targetRegion = regionFromArn(proxy.getDbProxyArn());
- proxyManager.startProxy(dbProxyRelayKey(proxy), engine, proxy.isIamAuth(),
+ proxyManager.startProxy(dbProxyRelayKey(proxy), backendRuntimeId, engine, proxy.isIamAuth(),
proxy.getProxyPort(), backendHost, backendPort, proxy.getEndpointHost(),
effectiveMasterUser, masterPassword, dbName,
(user, pw) -> isCluster
@@ -8204,6 +8223,7 @@ public class RdsService implements Resettable, ResourceProvider {
}
boolean clusterTarget = "TRACKED_CLUSTER".equals(target.getType());
DatabaseEngine engine;
+ String backendRuntimeId;
String backendHost;
int backendPort;
String masterUser;
@@ -8219,6 +8239,7 @@ public class RdsService implements Resettable, ResourceProvider {
validateProxyTargetScope(cluster.getDbClusterArn(), accountId, proxyRegion,
"DB cluster", target.getRdsResourceId());
engine = cluster.getEngine();
+ backendRuntimeId = cluster.getDbClusterArn();
backendHost = cluster.getContainerHost();
backendPort = cluster.getContainerPort();
masterUser = cluster.getMasterUsername();
@@ -8234,6 +8255,7 @@ public class RdsService implements Resettable, ResourceProvider {
validateProxyTargetScope(instance.getDbInstanceArn(), accountId, proxyRegion,
"DB instance", target.getRdsResourceId());
engine = instance.getEngine();
+ backendRuntimeId = instanceBackendIdentity(instance).runtimeId();
backendHost = instance.getContainerHost();
backendPort = instance.getContainerPort();
masterUser = instance.getMasterUsername();
@@ -8247,7 +8269,7 @@ public class RdsService implements Resettable, ResourceProvider {
validateTargetEngineFamily(proxy, engine);
String effectiveMasterUser = masterUser != null ? masterUser : "root";
String targetId = target.getRdsResourceId();
- proxyManager.startProxy(dbProxyRelayKey(proxy), engine, proxy.isIamAuth(), proxy.getProxyPort(),
+ proxyManager.startProxy(dbProxyRelayKey(proxy), backendRuntimeId, engine, proxy.isIamAuth(), proxy.getProxyPort(),
backendHost, backendPort, proxy.getEndpointHost(), effectiveMasterUser, masterPassword, dbName,
(user, password) -> clusterTarget
? validateDbClusterPasswordForScope(
@@ -8356,7 +8378,7 @@ public class RdsService implements Resettable, ResourceProvider {
? cluster.getMasterUsername() : "root";
proxyManager.startProxy(rdsResourceRelayKey(
cluster.getDbClusterArn(), cluster.getDbClusterIdentifier()),
- cluster.getEngine(),
+ cluster.getDbClusterArn(), cluster.getEngine(),
cluster.isIamDatabaseAuthenticationEnabled(), proxyPort,
restoredHandle.getHost(), restoredHandle.getPort(), cluster.getEndpoint().address(),
effectiveMasterUser, cluster.getMasterPassword(), cluster.getDatabaseName(),
@@ -8497,17 +8519,19 @@ public class RdsService implements Resettable, ResourceProvider {
if (hasBackend(backendHost, backendPort)) {
String effectiveMasterUser = instance.getMasterUsername() != null
? instance.getMasterUsername() : "root";
+ InstanceBackendIdentity backendIdentity = instanceBackendIdentity(instance);
proxyManager.startProxy(rdsResourceRelayKey(
instance.getDbInstanceArn(), instance.getDbInstanceIdentifier()),
- instance.getEngine(),
+ backendIdentity.runtimeId(), instance.getEngine(),
instance.isIamDatabaseAuthenticationEnabled(), proxyPort,
backendHost, backendPort, instance.getEndpoint().address(),
effectiveMasterUser, instance.getMasterPassword(), instance.getDbName(),
(user, pw) -> validateDbPasswordForScope(
accountId, instanceRegion,
instance.getDbInstanceIdentifier(), user, pw),
- proxyBinding(instance.getEngine(), instance.getEndpoint().address(), instance.getEndpoint().port(),
- instanceRegion, accountId, dbUserResourceId(instance)));
+ proxyBinding(instance.getEngine(), instance.getEndpoint().address(),
+ instance.getEndpoint().port(), instanceRegion, accountId,
+ backendIdentity.dbUserResourceId()));
}
instance.setStatus(DbInstanceStatus.AVAILABLE);
putInstanceForScope(accountId, instanceRegion,
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsBackendGate.java b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsBackendGate.java
index ffe1b37194..57647be07e 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsBackendGate.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsBackendGate.java
@@ -28,6 +28,14 @@ public interface RdsBackendGate {
return enter(host, port);
}
+ /**
+ * Enters the container owned by {@code runtimeId}. Backends that do not track runtime
+ * identities may use this default implementation.
+ */
+ default Lease enterRuntime(String runtimeId) throws InterruptedException {
+ return Lease.NONE;
+ }
+
/** The backend is being resumed; no lease was acquired and the caller must retry. */
class ResumingException extends RuntimeException {
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java
index b8aa743699..e651b1b326 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java
@@ -460,6 +460,21 @@ public class RdsContainerManager implements RdsBackendGate, Resettable {
return lifecycleManager.probeContainer(containerId);
}
+ /** Resolves the current endpoint for the container owned by an RDS runtime. */
+ public EndpointInfo resolveBackendEndpoint(String runtimeId, DatabaseEngine engine) {
+ if (runtimeId == null || runtimeId.isBlank()) {
+ throw new IllegalArgumentException("RDS runtime ID is required to resolve its backend endpoint");
+ }
+ RdsContainerHandle handle = activeContainers.get(runtimeId);
+ if (handle == null) {
+ throw new IllegalStateException("RDS runtime " + runtimeId + " has no active container");
+ }
+ String preferredNetwork = containerBuilder.resolveDockerNetwork(
+ config.services().rds().dockerNetwork()).orElse(null);
+ return lifecycleManager.resolveEndpoint(
+ handle.getContainerId(), engine.defaultPort(), preferredNetwork);
+ }
+
/** Returns the retained runtime handle used to persist cleanup identity after a failed start. */
public RdsContainerHandle getActiveHandle(String runtimeId) {
if (runtimeId == null || runtimeId.isBlank()) {
@@ -499,6 +514,12 @@ public class RdsContainerManager implements RdsBackendGate, Resettable {
controller.configure(enabled ? secondsUntilAutoPause : null, listener);
}
+ @Override
+ public Lease enterRuntime(String runtimeId) throws InterruptedException {
+ AutoPauseController controller = runtimeId != null ? autoPauses.get(runtimeId) : null;
+ return controller != null ? controller.acquire() : Lease.NONE;
+ }
+
@Override
public Lease enter(String host, int port) throws InterruptedException {
return enter(host, port, true);
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java
index 65ca18b19c..23c5510292 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxy.java
@@ -29,6 +29,8 @@ public class RdsAuthProxy {
private final String instanceId;
private final String backendHost;
+ private final BackendEndpointResolver backendEndpointResolver;
+ private final String backendRuntimeId;
private final String masterUsername;
private volatile String masterPassword;
private final String dbName;
@@ -98,9 +100,46 @@ public class RdsAuthProxy {
int maxConnections, RdsProxyBinding binding,
MySqlProtocolHandler.IamUserChecker iamUserChecker,
RdsBackendGate backendGate, EndpointKind endpointKind) {
+ this(instanceId, backendHost, backendPort,
+ () -> new BackendEndpoint(backendHost, backendPort),
+ engine, iamEnabled, masterUsername, masterPassword, dbName, sigV4,
+ tlsCertificates, passwordValidator, handshakeTimeoutMillis,
+ backendConnectTimeoutMillis, maxConnections, binding, iamUserChecker,
+ backendGate, endpointKind);
+ }
+
+ public RdsAuthProxy(String instanceId, String backendHost, int backendPort,
+ BackendEndpointResolver backendEndpointResolver,
+ DatabaseEngine engine, boolean iamEnabled,
+ String masterUsername, String masterPassword, String dbName,
+ RdsSigV4Validator sigV4, RdsProxyTlsCertificates tlsCertificates,
+ MasterPasswordCheck passwordValidator,
+ int handshakeTimeoutMillis, int backendConnectTimeoutMillis,
+ int maxConnections, RdsProxyBinding binding,
+ MySqlProtocolHandler.IamUserChecker iamUserChecker,
+ RdsBackendGate backendGate, EndpointKind endpointKind) {
+ this(instanceId, backendHost, backendPort, backendEndpointResolver, null,
+ engine, iamEnabled, masterUsername, masterPassword, dbName, sigV4,
+ tlsCertificates, passwordValidator, handshakeTimeoutMillis,
+ backendConnectTimeoutMillis, maxConnections, binding, iamUserChecker,
+ backendGate, endpointKind);
+ }
+
+ public RdsAuthProxy(String instanceId, String backendHost, int backendPort,
+ BackendEndpointResolver backendEndpointResolver, String backendRuntimeId,
+ DatabaseEngine engine, boolean iamEnabled,
+ String masterUsername, String masterPassword, String dbName,
+ RdsSigV4Validator sigV4, RdsProxyTlsCertificates tlsCertificates,
+ MasterPasswordCheck passwordValidator,
+ int handshakeTimeoutMillis, int backendConnectTimeoutMillis,
+ int maxConnections, RdsProxyBinding binding,
+ MySqlProtocolHandler.IamUserChecker iamUserChecker,
+ RdsBackendGate backendGate, EndpointKind endpointKind) {
this.instanceId = instanceId;
this.backendHost = backendHost;
this.backendPort = backendPort;
+ this.backendEndpointResolver = backendEndpointResolver;
+ this.backendRuntimeId = backendRuntimeId;
this.engine = engine;
this.iamEnabled = iamEnabled;
this.endpointKind = endpointKind;
@@ -202,7 +241,9 @@ public class RdsAuthProxy {
try {
// An auto-paused Aurora backend resumes before the client is served: the client is
// held, not refused, and the backend stays awake for as long as the connection lasts.
- lease = backendGate.enter(backendHost, backendPort);
+ lease = backendRuntimeId != null
+ ? backendGate.enterRuntime(backendRuntimeId)
+ : backendGate.enter(backendHost, backendPort);
client.setTcpNoDelay(true);
// RDS only proxy-validates the master user; a non-master user passes through so the
@@ -217,8 +258,9 @@ public class RdsAuthProxy {
};
PostgresProtocolHandler.BackendConnector connector = () -> {
+ BackendEndpoint endpoint = backendEndpointResolver.resolve();
Socket backendSocket = new Socket();
- backendSocket.connect(new InetSocketAddress(backendHost, backendPort),
+ backendSocket.connect(new InetSocketAddress(endpoint.host(), endpoint.port()),
backendConnectTimeoutMillis);
backendSocket.setTcpNoDelay(true);
return backendSocket;
@@ -282,6 +324,15 @@ public class RdsAuthProxy {
}
}
+ /** Backend address resolved immediately before each outbound connection attempt. */
+ public record BackendEndpoint(String host, int port) {}
+
+ /** Resolves the current backend address for a new outbound connection. */
+ @FunctionalInterface
+ public interface BackendEndpointResolver {
+ BackendEndpoint resolve() throws IOException;
+ }
+
/**
* Callback for master-password validation, implemented by RdsService. Returns true when the
* supplied master credentials are current. Non-master users are never asked here: the backend
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java
index 1780786a85..c61ccb54e8 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManager.java
@@ -1,7 +1,9 @@
package io.github.hectorvent.floci.services.rds.proxy;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;
import io.github.hectorvent.floci.services.rds.container.RdsBackendGate;
+import io.github.hectorvent.floci.services.rds.container.RdsContainerManager;
import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -9,6 +11,7 @@ import org.jboss.logging.Logger;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
/**
* Registry of all active RDS auth proxies. One proxy per DB instance or cluster.
@@ -22,46 +25,78 @@ public class RdsProxyManager {
private final RdsProxyTlsCertificates tlsCertificates;
private final EmulatorConfig config;
private final RdsBackendGate backendGate;
+ private final RdsContainerManager containerManager;
private final ConcurrentHashMap<String, RdsAuthProxy> proxies = new ConcurrentHashMap<>();
@Inject
public RdsProxyManager(RdsSigV4Validator sigV4Validator, RdsProxyTlsCertificates tlsCertificates,
- EmulatorConfig config, RdsBackendGate backendGate) {
+ EmulatorConfig config, RdsBackendGate backendGate,
+ RdsContainerManager containerManager) {
this.sigV4Validator = sigV4Validator;
this.tlsCertificates = tlsCertificates;
this.config = config;
this.backendGate = backendGate;
+ this.containerManager = containerManager;
}
- RdsProxyManager(RdsSigV4Validator sigV4Validator, RdsProxyTlsCertificates tlsCertificates,
- EmulatorConfig config) {
- this(sigV4Validator, tlsCertificates, config, RdsBackendGate.OPEN);
- }
-
- public synchronized void startProxy(String instanceId, DatabaseEngine engine, boolean iamEnabled,
+ public synchronized void startProxy(String instanceId, String backendRuntimeId,
+ DatabaseEngine engine, boolean iamEnabled,
int proxyPort, String backendHost, int backendPort,
String advertisedHost,
String masterUsername, String masterPassword, String dbName,
RdsAuthProxy.MasterPasswordCheck passwordValidator,
RdsProxyBinding binding) {
- startProxy(instanceId, engine, iamEnabled, proxyPort, backendHost, backendPort,
- advertisedHost, masterUsername, masterPassword, dbName, passwordValidator,
- binding, RdsAuthProxy.EndpointKind.DATABASE);
+ startProxy(instanceId, backendRuntimeId, engine, iamEnabled, proxyPort, backendHost,
+ backendPort, advertisedHost, masterUsername, masterPassword, dbName,
+ passwordValidator, binding, RdsAuthProxy.EndpointKind.DATABASE);
}
- public synchronized void startProxy(String instanceId, DatabaseEngine engine, boolean iamEnabled,
+ public synchronized void startProxy(String instanceId, String backendRuntimeId,
+ DatabaseEngine engine, boolean iamEnabled,
int proxyPort, String backendHost, int backendPort,
String advertisedHost,
String masterUsername, String masterPassword, String dbName,
RdsAuthProxy.MasterPasswordCheck passwordValidator,
RdsProxyBinding binding, RdsAuthProxy.EndpointKind endpointKind) {
+ if (containerManager == null) {
+ throw new IllegalStateException("RDS container manager is required for dynamic backend resolution");
+ }
+ AtomicBoolean endpointFailureLogged = new AtomicBoolean();
+ RdsAuthProxy.BackendEndpointResolver endpointResolver = () -> {
+ try {
+ EndpointInfo endpoint = containerManager.resolveBackendEndpoint(backendRuntimeId, engine);
+ endpointFailureLogged.set(false);
+ return new RdsAuthProxy.BackendEndpoint(endpoint.host(), endpoint.port());
+ } catch (RuntimeException e) {
+ if (endpointFailureLogged.compareAndSet(false, true)) {
+ LOG.warnv(e, "Could not resolve backend endpoint for RDS runtime {0}",
+ backendRuntimeId);
+ }
+ throw new IOException(
+ "Could not resolve backend endpoint for RDS runtime " + backendRuntimeId, e);
+ }
+ };
+ startProxy(instanceId, backendRuntimeId, engine, iamEnabled, proxyPort,
+ backendHost, backendPort, endpointResolver, advertisedHost, masterUsername,
+ masterPassword, dbName, passwordValidator, binding, endpointKind);
+ }
+
+ private void startProxy(String instanceId, String backendRuntimeId,
+ DatabaseEngine engine, boolean iamEnabled,
+ int proxyPort, String backendHost, int backendPort,
+ RdsAuthProxy.BackendEndpointResolver endpointResolver,
+ String advertisedHost,
+ String masterUsername, String masterPassword, String dbName,
+ RdsAuthProxy.MasterPasswordCheck passwordValidator,
+ RdsProxyBinding binding, RdsAuthProxy.EndpointKind endpointKind) {
tlsCertificates.ensureHost(advertisedHost);
EmulatorConfig.RdsServiceConfig rdsConfig = config.services().rds();
RdsAuthProxy proxy = new RdsAuthProxy(
- instanceId, backendHost, backendPort, engine, iamEnabled,
- masterUsername, masterPassword, dbName, sigV4Validator, tlsCertificates, passwordValidator,
- rdsConfig.proxyHandshakeTimeoutMillis(), rdsConfig.proxyBackendConnectTimeoutMillis(),
- rdsConfig.proxyMaxConnections(), binding, username -> binding != null, backendGate, endpointKind);
+ instanceId, backendHost, backendPort, endpointResolver, backendRuntimeId,
+ engine, iamEnabled, masterUsername, masterPassword, dbName, sigV4Validator,
+ tlsCertificates, passwordValidator, rdsConfig.proxyHandshakeTimeoutMillis(),
+ rdsConfig.proxyBackendConnectTimeoutMillis(), rdsConfig.proxyMaxConnections(),
+ binding, username -> binding != null, backendGate, endpointKind);
try {
proxy.start(proxyPort);
} catch (IOException e) {
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerNetworkTest.java b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerNetworkTest.java
index 35e806a364..e28ba43e10 100644
--- a/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerNetworkTest.java
+++ b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerNetworkTest.java
@@ -278,6 +278,37 @@ class ContainerLifecycleManagerNetworkTest {
assertEquals(new EndpointInfo("localhost", 9200), info.getEndpoint(9200));
}
+ @Test
+ void resolveEndpointFailsClosedWhenNativePortBindingIsMissing() {
+ when(containerDetector.isRunningInContainer()).thenReturn(false);
+ InspectContainerResponse inspect = inspectOf("container-id");
+ NetworkSettings networks = mock(NetworkSettings.class);
+ when(inspect.getNetworkSettings()).thenReturn(networks);
+ when(networks.getPorts()).thenReturn(new Ports());
+
+ IllegalStateException failure = assertThrows(IllegalStateException.class,
+ () -> manager().resolveEndpoint("container-id", 5432));
+
+ assertTrue(failure.getMessage().contains("no published binding"));
+ }
+
+ @Test
+ void resolveEndpointFailsClosedWhenContainerAddressIsMissing() {
+ when(containerDetector.isRunningInContainer()).thenReturn(true);
+ InspectContainerResponse inspect = inspectOf("container-id");
+ NetworkSettings networks = mock(NetworkSettings.class);
+ when(inspect.getHostConfig()).thenReturn(HostConfig.newHostConfig().withNetworkMode("bridge"));
+ when(inspect.getNetworkSettings()).thenReturn(networks);
+ when(networks.getNetworks()).thenReturn(Map.of(
+ "floci-net", new ContainerNetwork().withIpv4Address("")));
+ when(networks.getIpAddress()).thenReturn("");
+
+ IllegalStateException failure = assertThrows(IllegalStateException.class,
+ () -> manager().resolveEndpoint("container-id", 5432, "floci-net"));
+
+ assertTrue(failure.getMessage().contains("no reachable address"));
+ }
+
@Test
void resolveEndpointPrefersTheServiceNetworkOverTheDefaultBridge() {
when(containerDetector.isRunningInContainer()).thenReturn(true);
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
index 0049a5de8d..564f0892b2 100644
--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
@@ -263,11 +263,11 @@ class RdsServiceTest {
doAnswer(invocation -> {
assertEquals(DbInstanceStatus.CREATING,
rdsService.getDbInstance("mypostgres").getStatus());
- RdsAuthProxy.MasterPasswordCheck passwordCheck = invocation.getArgument(10);
+ RdsAuthProxy.MasterPasswordCheck passwordCheck = invocation.getArgument(11);
assertTrue(passwordCheck.validate("admin", "secret123"));
assertFalse(passwordCheck.validate("admin", "wrong"));
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
DbInstance instance = rdsService.createDbInstance("mypostgres", "postgres", "13",
@@ -286,8 +286,10 @@ class RdsServiceTest {
20, false, null, null, null, null, false);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
- any(), any(), any(), any(), any(), binding.capture());
+ verify(proxyManager).startProxy(
+ eq("rds-resource:" + instance.getDbInstanceArn()), eq(instance.getDbInstanceArn()),
+ any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(),
+ binding.capture());
assertEquals(new RdsProxyBinding(instance.getEndpoint().address(), instance.getProxyPort(),
"us-east-1", "123456789012", instance.getDbiResourceId(), true),
binding.getValue());
@@ -322,7 +324,8 @@ class RdsServiceTest {
}
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
- any(), eq(true), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), binding.capture());
+ eq(cluster.getDbClusterArn()), any(), eq(true), anyInt(), any(), anyInt(), any(),
+ any(), any(), any(), any(), binding.capture());
assertEquals(cluster.getDbClusterResourceId(), binding.getValue().resourceId());
assertNotEquals(member.getDbiResourceId(), binding.getValue().resourceId());
assertEquals("123456789012", binding.getValue().accountId());
@@ -358,8 +361,11 @@ class RdsServiceTest {
for (String account : List.of(defaultAccount, "999999999999")) {
for (String region : List.of("us-east-1", "us-west-2")) {
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(eq("rds-resource:arn:aws:rds:" + region + ":" + account + ":db:member"),
- any(), eq(true), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), binding.capture());
+ verify(proxyManager).startProxy(
+ eq("rds-resource:arn:aws:rds:" + region + ":" + account + ":db:member"),
+ eq("arn:aws:rds:" + region + ":" + account + ":cluster:cluster1"),
+ any(), eq(true), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(),
+ binding.capture());
assertEquals("cluster-" + account + "-" + region, binding.getValue().resourceId());
assertEquals(account, binding.getValue().accountId());
assertEquals(region, binding.getValue().region());
@@ -609,7 +615,7 @@ class RdsServiceTest {
return null;
}).when(certificates).ensureHost(anyString());
RdsProxyManager manager = new RdsProxyManager(mock(RdsSigV4Validator.class), certificates,
- config, RdsBackendGate.OPEN);
+ config, RdsBackendGate.OPEN, containerManager);
RdsService service = newService(containerManager, manager, new InMemoryStorage<>(),
new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());
service.createGlobalCluster("unrelated-global", null, "aurora-postgresql", "16.3",
@@ -658,10 +664,10 @@ class RdsServiceTest {
return result;
}).when(instances).put(any(), any());
doAnswer(call -> {
- proxyIam.set(call.getArgument(2));
+ proxyIam.set(call.getArgument(3));
installed.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
doAnswer(call -> {
String key = call.getArgument(0);
@@ -765,12 +771,12 @@ class RdsServiceTest {
}).when(instances).put(any(), any());
doAnswer(call -> {
if (((String) call.getArgument(0)).endsWith(":db:race-member")) {
- memberBackend.set(call.getArgument(4));
+ memberBackend.set(call.getArgument(5));
}
- proxyIam.set(call.getArgument(2));
+ proxyIam.set(call.getArgument(3));
installed.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
doAnswer(call -> {
String key = call.getArgument(0);
@@ -907,8 +913,9 @@ class RdsServiceTest {
assertNotNull(started.getContainerId());
verify(containerManager).tryStart(eq(cluster.getDbClusterArn()), eq("offline-credentials"), any(), any(),
eq(cluster.getEngine()), any(), eq("clusteradmin"), eq("AcceptedPassword!"), eq("dbname"));
- verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()), any(), anyBoolean(),
- anyInt(), any(), anyInt(), any(), eq("clusteradmin"), eq("AcceptedPassword!"), eq("dbname"), any(), any());
+ verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(), any(),
+ eq("clusteradmin"), eq("AcceptedPassword!"), eq("dbname"), any(), any());
}
@ParameterizedTest
@@ -933,7 +940,8 @@ class RdsServiceTest {
if (mockMode) {
verifyNoInteractions(proxyManager);
} else {
- verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()), any(),
+ verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
+ eq("arn:aws:rds:us-east-1:123456789012:cluster:iam-cluster"), any(),
eq(clusterEnabled), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
}
}
@@ -960,8 +968,9 @@ class RdsServiceTest {
} else {
assertFalse(rdsService.validateDbPassword("incomplete-credentials-member", expectedUser, "invented-password"));
}
- verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()), any(), eq(true),
- anyInt(), any(), anyInt(), any(), eq(expectedUser), eq(expectedPassword),
+ verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
+ eq("arn:aws:rds:us-east-1:123456789012:cluster:incomplete-credentials-cluster"),
+ any(), eq(true), anyInt(), any(), anyInt(), any(), eq(expectedUser), eq(expectedPassword),
eq("dbname"), any(), any());
}
@@ -995,9 +1004,9 @@ class RdsServiceTest {
assertEquals("clusteradmin", member.getMasterUsername());
assertEquals("RotatedPassword!", member.getMasterPassword());
assertEquals("RotatedPassword!", rdsService.getDbInstance("credential-race-member").getMasterPassword());
- verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()), any(), eq(true),
- anyInt(), any(), anyInt(), any(), eq("clusteradmin"), eq("RotatedPassword!"),
- eq("dbname"), any(), any());
+ verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
+ eq(cluster.getDbClusterArn()), any(), eq(true), anyInt(), any(), anyInt(), any(),
+ eq("clusteradmin"), eq("RotatedPassword!"), eq("dbname"), any(), any());
} finally {
release.countDown();
worker.shutdownNow();
@@ -1032,7 +1041,7 @@ class RdsServiceTest {
verifyNoInteractions(proxyManager);
} else {
verify(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
- any(), eq(true), anyInt(), any(), anyInt(), any(),
+ eq(cluster.getDbClusterArn()), any(), eq(true), anyInt(), any(), anyInt(), any(),
eq("clusteradmin"), eq("ClusterPassword!"), eq("dbname"), any(), any());
}
}
@@ -1046,7 +1055,7 @@ class RdsServiceTest {
20, false, null, null, null, null, false);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), binding.capture());
assertFalse(binding.getValue().tokensBoundToEndpoint());
}
@@ -1060,7 +1069,7 @@ class RdsServiceTest {
20, false, null, null, null, null, false);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), binding.capture());
assertTrue(binding.getValue().tokensBoundToEndpoint(),
"MySQL bound tokens to the endpoint before the setting existed and keeps doing so");
@@ -1069,7 +1078,7 @@ class RdsServiceTest {
@Test
void createDbInstanceRemovesVisibleRecordWhenProxyStartupFails() {
doThrow(new IllegalStateException("proxy down"))
- .when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ .when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
assertThrows(IllegalStateException.class, () -> rdsService.createDbInstance(
@@ -1724,7 +1733,7 @@ class RdsServiceTest {
assertEquals(49173, instance.getEndpoint().port());
assertEquals(7000, instance.getProxyPort());
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
any(), any(), any(), any(), any(), binding.capture());
assertEquals(new RdsProxyBinding("localhost", 49173, "us-east-1", "123456789012",
instance.getDbiResourceId(), true), binding.getValue());
@@ -1745,7 +1754,7 @@ class RdsServiceTest {
"admin", "password", "dbname", "db.t3.micro", 20, true, null, null, null);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
any(), any(), any(), any(), any(), binding.capture());
assertEquals(advertisedPort, instance.getEndpoint().port());
assertEquals(new RdsProxyBinding(instance.getEndpoint().address(), instance.getEndpoint().port(),
@@ -1768,7 +1777,7 @@ class RdsServiceTest {
"admin", "password", "app", true, null);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), eq(7000), any(), anyInt(),
any(), any(), any(), any(), any(), binding.capture());
assertEquals(advertisedPort, cluster.getEndpoint().port());
assertEquals(new RdsProxyBinding(cluster.getEndpoint().address(), cluster.getEndpoint().port(),
@@ -1785,8 +1794,9 @@ class RdsServiceTest {
RdsService service = new RdsService(containerManager, proxyManager, ec2Service, regionResolver, config,
new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
new InMemoryStorage<>(), new InMemoryStorage<>(), null, null, resolver);
- service.createDbInstance("mydb", engine, null, "admin", "password", "app",
- "db.t3.micro", 20, true, null, null, null);
+ DbInstance target = service.createDbInstance("mydb", engine, null,
+ "admin", "password", "app", "db.t3.micro", 20,
+ true, null, null, null);
DbProxy first = service.createDbProxy("proxy-a", family, true, true, PROXY_ROLE_ARN,
PROXY_SUBNET_IDS, List.of(), PROXY_AUTH, Map.of());
DbProxy second = service.createDbProxy("proxy-b", family, true, true, PROXY_ROLE_ARN,
@@ -1797,16 +1807,20 @@ class RdsServiceTest {
service.registerDbProxyTargets(proxy.getDbProxyName(), null,
List.of(), List.of("mydb"), 90, 40);
ArgumentCaptor<RdsProxyBinding> binding = ArgumentCaptor.forClass(RdsProxyBinding.class);
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), eq(proxy.getProxyPort()), any(), anyInt(),
- any(), any(), any(), any(), any(), binding.capture(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
+ verify(proxyManager).startProxy(
+ any(), eq(target.getDbInstanceArn()), any(), anyBoolean(),
+ eq(proxy.getProxyPort()), any(), anyInt(), any(), any(), any(), any(), any(),
+ binding.capture(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
assertEquals(proxy.getEndpointHost(), proxy.getEndpoint());
assertEquals(new RdsProxyBinding(proxy.getEndpointHost(), proxy.getProxyPort(), "us-east-1",
"123456789012", proxy.getDbProxyResourceId(), true), binding.getValue());
clearInvocations(proxyManager);
service.modifyDbProxy(proxy.getDbProxyName(), null, PROXY_AUTH, null, null, null,
null, null, null, "us-east-1");
- verify(proxyManager).startProxy(any(), any(), eq(false), eq(proxy.getProxyPort()), any(), anyInt(),
- any(), any(), any(), any(), any(), binding.capture(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
+ verify(proxyManager).startProxy(
+ any(), eq(target.getDbInstanceArn()), any(), eq(false),
+ eq(proxy.getProxyPort()), any(), anyInt(), any(), any(), any(), any(), any(),
+ binding.capture(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
assertEquals(new RdsProxyBinding(proxy.getEndpointHost(), proxy.getProxyPort(), "us-east-1",
"123456789012", proxy.getDbProxyResourceId(), true), binding.getValue());
clearInvocations(proxyManager);
@@ -2182,7 +2196,7 @@ class RdsServiceTest {
when(secretsManager.createSecret(any(), any(), eq(null), any(), eq(null), any(), eq("rds"), eq("us-east-1")))
.thenReturn(secret);
doThrow(new IllegalStateException("proxy down"))
- .when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ .when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
RdsService service = newService(containerManager, proxyManager,
new InMemoryStorage<>(), new InMemoryStorage<>(),
@@ -3241,7 +3255,7 @@ class RdsServiceTest {
assertEquals("DBSubnetGroupNotFoundFault", exception.getErrorCode());
verify(containerManager, never()).tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(),
any(), anyInt(), any(), any(), any(), any(), any(), any());
}
@@ -3373,7 +3387,7 @@ class RdsServiceTest {
assertTrue(cluster.getEndpoint().port() > 0);
assertNull(cluster.getContainerId());
verify(containerManager, never()).tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
}
@@ -3702,7 +3716,7 @@ class RdsServiceTest {
// fallback would fabricate a name that a later non-mock restore could try to reference.
assertNull(instance.getDockerVolumeName());
verify(containerManager, never()).tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
}
@@ -3729,7 +3743,7 @@ class RdsServiceTest {
assertNull(instance.getContainerHost());
assertEquals(0, instance.getContainerPort());
assertNotNull(instance.getVolumeId());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
}
@@ -3795,7 +3809,7 @@ class RdsServiceTest {
assertNotNull(cluster.getVolumeId());
assertEquals(DbInstanceStatus.AVAILABLE, member.getStatus());
assertNull(member.getContainerId());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
rdsService.deleteDbInstance("probe-member");
@@ -3835,8 +3849,9 @@ class RdsServiceTest {
eq(DatabaseEngine.POSTGRES), eq("postgres:16.3-alpine"),
eq("admin"), eq("password"), eq("dbname"));
verify(proxyManager).startProxy(
- eq("rds-resource:" + created.getDbInstanceArn()), eq(DatabaseEngine.POSTGRES),
- eq(false), eq(created.getProxyPort()), eq("127.0.0.1"), eq(15432), any(),
+ eq("rds-resource:" + created.getDbInstanceArn()), eq(created.getDbInstanceArn()),
+ eq(DatabaseEngine.POSTGRES), eq(false), eq(created.getProxyPort()),
+ eq("127.0.0.1"), eq(15432), any(),
eq("admin"), eq("password"), eq("dbname"), any(), any());
// Already backed, so a further call is a no-op rather than a second container. Three
@@ -3859,7 +3874,7 @@ class RdsServiceTest {
when(containerManager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))
.thenReturn(late);
doThrow(new IllegalStateException("port in use")).doNothing()
- .when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ .when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
assertThrows(IllegalStateException.class,
@@ -3907,11 +3922,13 @@ class RdsServiceTest {
eq(cluster.getDbClusterArn()), eq("probe-cluster"), any(), any(),
eq(DatabaseEngine.POSTGRES), any(), eq("admin"), eq("password"), eq("dbname"));
verify(proxyManager).startProxy(
- eq("rds-resource:" + cluster.getDbClusterArn()), any(), anyBoolean(),
- eq(cluster.getProxyPort()), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq("rds-resource:" + cluster.getDbClusterArn()), eq(cluster.getDbClusterArn()),
+ any(), anyBoolean(), eq(cluster.getProxyPort()), eq("127.0.0.1"), eq(15432),
+ any(), any(), any(), any(), any(), any());
verify(proxyManager).startProxy(
- eq("rds-resource:" + member.getDbInstanceArn()), any(), anyBoolean(),
- eq(member.getProxyPort()), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq("rds-resource:" + member.getDbInstanceArn()), eq(cluster.getDbClusterArn()),
+ any(), anyBoolean(), eq(member.getProxyPort()), eq("127.0.0.1"), eq(15432),
+ any(), any(), any(), any(), any(), any());
}
@Test
@@ -3933,8 +3950,9 @@ class RdsServiceTest {
// There was no container to stop, only one to start.
verify(containerManager, never()).stop(any());
verify(proxyManager).startProxy(
- eq("rds-resource:" + created.getDbInstanceArn()), any(), anyBoolean(),
- eq(created.getProxyPort()), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq("rds-resource:" + created.getDbInstanceArn()), eq(created.getDbInstanceArn()),
+ any(), anyBoolean(), eq(created.getProxyPort()), eq("127.0.0.1"), eq(15432),
+ any(), any(), any(), any(), any(), any());
}
@Test
@@ -3962,7 +3980,7 @@ class RdsServiceTest {
assertEquals(created.getProxyPort(), restored.getProxyPort());
assertEquals(created.getProxyPort(), restored.getEndpoint().port());
assertNull(restored.getContainerId());
- verify(daemonlessProxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(),
+ verify(daemonlessProxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(),
any(), anyInt(), any(), any(), any(), any(), any(), any());
}
@@ -3992,7 +4010,7 @@ class RdsServiceTest {
DbInstance restoredMember = restoredService.getDbInstance("member1");
assertEquals(DbInstanceStatus.AVAILABLE, restoredMember.getStatus());
assertNull(restoredMember.getContainerId());
- verify(daemonlessProxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(),
+ verify(daemonlessProxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(),
any(), anyInt(), any(), any(), any(), any(), any(), any());
}
@@ -4076,7 +4094,7 @@ class RdsServiceTest {
assertEquals("cont-id", started.getContainerId());
assertEquals(port, started.getEndpoint().port());
verify(containerManager, times(2)).tryStart(any(), any(), any(), eq(volume), any(), any(), any(), any(), any());
- verify(proxyManager, times(2)).startProxy(any(), any(), anyBoolean(), eq(port), any(), anyInt(),
+ verify(proxyManager, times(2)).startProxy(any(), any(), any(), anyBoolean(), eq(port), any(), anyInt(),
any(), any(), any(), any(), any(), any());
assertEquals("InvalidDBInstanceState", assertThrows(AwsException.class,
() -> rdsService.startDbInstance("standalone")).getErrorCode());
@@ -4223,7 +4241,7 @@ class RdsServiceTest {
assertEquals(DbInstanceStatus.AVAILABLE, rebooted.getStatus());
verify(containerManager, never()).tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any());
verify(containerManager, never()).stop(any());
- verify(proxyManager, never()).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ verify(proxyManager, never()).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
}
@@ -4880,8 +4898,8 @@ class RdsServiceTest {
eq(restored.getDockerVolumeName()), eq(DatabaseEngine.POSTGRES),
eq("postgres:16.3-alpine"), eq("admin"), eq("secret"), eq("app"));
verify(restoredProxyManager).startProxy(
- eq("rds-resource:" + restored.getDbInstanceArn()), eq(DatabaseEngine.POSTGRES),
- eq(false), eq(persistedProxyPort), eq("127.0.0.1"), eq(15432), any(),
+ eq("rds-resource:" + restored.getDbInstanceArn()), eq(restored.getDbInstanceArn()),
+ eq(DatabaseEngine.POSTGRES), eq(false), eq(persistedProxyPort), eq("127.0.0.1"), eq(15432), any(),
eq("admin"), eq("secret"), eq("app"), any(), any());
restoredService.deleteDbInstance("mydb");
@@ -4933,11 +4951,13 @@ class RdsServiceTest {
eq(restoredCluster.getDockerVolumeName()), eq(DatabaseEngine.POSTGRES),
eq("postgres:16.3-alpine"), eq("admin"), eq("secret"), eq("app"));
verify(restoredProxyManager).startProxy(
- eq("rds-resource:" + restoredCluster.getDbClusterArn()), eq(DatabaseEngine.POSTGRES),
+ eq("rds-resource:" + restoredCluster.getDbClusterArn()),
+ eq(restoredCluster.getDbClusterArn()), eq(DatabaseEngine.POSTGRES),
eq(false), eq(cluster.getProxyPort()), eq("127.0.0.1"), eq(15432), any(),
eq("admin"), eq("secret"), eq("app"), any(), any());
verify(restoredProxyManager).startProxy(
- eq("rds-resource:" + restoredMember.getDbInstanceArn()), eq(DatabaseEngine.POSTGRES),
+ eq("rds-resource:" + restoredMember.getDbInstanceArn()),
+ eq(restoredCluster.getDbClusterArn()), eq(DatabaseEngine.POSTGRES),
eq(false), eq(member.getProxyPort()), eq("127.0.0.1"), eq(15432), any(),
eq("admin"), eq("secret"), eq("app"), any(), any());
}
@@ -5062,7 +5082,7 @@ class RdsServiceTest {
assertEquals(expected, rdsService.getDbInstance("iam-restored").isIamDatabaseAuthenticationEnabled());
assertEquals(sourceEnabled, source.isIamDatabaseAuthenticationEnabled());
assertEquals(sourceEnabled, snapshot.isIamDatabaseAuthenticationEnabled());
- verify(proxyManager).startProxy(any(), any(), eq(expected), anyInt(), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), eq(expected), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
if (requested == null) {
DbInstance legacy = rdsService.restoreDbInstanceFromDbSnapshot("iam-legacy", "iam-snapshot",
@@ -5478,7 +5498,7 @@ class RdsServiceTest {
assertEquals(expected, rdsService.getDbCluster("iam-restored").isIamDatabaseAuthenticationEnabled());
assertEquals(sourceEnabled, source.isIamDatabaseAuthenticationEnabled());
assertEquals(sourceEnabled, snapshot.isIamDatabaseAuthenticationEnabled());
- verify(proxyManager).startProxy(any(), any(), eq(expected), anyInt(), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), eq(expected), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
}
@@ -5534,7 +5554,7 @@ class RdsServiceTest {
assertEquals(7005, restored.getEndpoint().port());
assertEquals(7005, restored.getProxyPort());
assertEquals(7005, rdsService.getDbCluster("restored-cluster").getEndpoint().port());
- verify(proxyManager).startProxy(any(), any(), anyBoolean(), eq(7005), any(), anyInt(),
+ verify(proxyManager).startProxy(any(), any(), any(), anyBoolean(), eq(7005), any(), anyInt(),
any(), any(), any(), any(), any(), any());
assertEquals("InvalidParameterValue", assertThrows(AwsException.class,
@@ -5783,7 +5803,7 @@ class RdsServiceTest {
.doNothing()
.doNothing()
.when(restoredProxyManager).startProxy(
- any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
org.mockito.Mockito.doThrow(new IllegalStateException("cleanup failed"))
.doNothing()
@@ -5897,8 +5917,9 @@ class RdsServiceTest {
assertEquals(7005, retried.getProxyPort());
assertEquals("retried-container", retried.getContainerId());
verify(restoredProxyManager).startProxy(
- eq("rds-resource:" + persisted.getDbInstanceArn()), any(), anyBoolean(),
- eq(7005), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq("rds-resource:" + persisted.getDbInstanceArn()), eq(persisted.getDbInstanceArn()),
+ any(), anyBoolean(), eq(7005), eq("127.0.0.1"), eq(15432),
+ any(), any(), any(), any(), any(), any());
}
@Test
@@ -6003,7 +6024,7 @@ class RdsServiceTest {
assertEquals("recovered-container", retried.getContainerId());
assertNotNull(retried.getEndpoint());
assertEquals(7000, retried.getProxyPort());
- verify(proxies).startProxy(any(), any(), anyBoolean(), eq(retried.getProxyPort()),
+ verify(proxies).startProxy(any(), any(), any(), anyBoolean(), eq(retried.getProxyPort()),
eq("127.0.0.1"), eq(15432), eq(retried.getEndpoint().address()),
any(), any(), any(), any(), any());
}
@@ -6026,7 +6047,7 @@ class RdsServiceTest {
when(manager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))
.thenReturn(recovered);
doThrow(new IllegalStateException("temporary relay error")).doNothing()
- .when(proxies).startProxy(any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ .when(proxies).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
RdsService service = newService(manager, proxies, new InMemoryStorage<>(), clusters,
new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());
@@ -6073,7 +6094,7 @@ class RdsServiceTest {
assertEquals(DbInstanceStatus.AVAILABLE, started.getStatus());
assertNotNull(started.getEndpoint());
assertEquals(7000, started.getProxyPort());
- verify(proxies).startProxy(any(), any(), anyBoolean(), eq(7000), eq("127.0.0.1"),
+ verify(proxies).startProxy(any(), any(), any(), anyBoolean(), eq(7000), eq("127.0.0.1"),
eq(15432), eq(started.getEndpoint().address()), any(), any(), any(), any(), any());
}
@@ -6128,7 +6149,7 @@ class RdsServiceTest {
assertEquals(7000, started.getEndpoint().port());
assertEquals(started.getEndpoint(), started.getReaderEndpoint());
verify(proxies).startProxy(eq("rds-resource:" + started.getDbClusterArn()),
- any(), anyBoolean(), eq(started.getProxyPort()),
+ eq(started.getDbClusterArn()), any(), anyBoolean(), eq(started.getProxyPort()),
eq("127.0.0.1"), eq(15432), eq(started.getEndpoint().address()),
any(), any(), any(), any(), any());
assertEquals(DbInstanceStatus.AVAILABLE, member.getStatus());
@@ -6136,8 +6157,9 @@ class RdsServiceTest {
assertEquals(7001, member.getEndpoint().port());
assertEquals("recovered-container", member.getContainerId());
verify(proxies).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
- any(), anyBoolean(), eq(member.getProxyPort()), eq("127.0.0.1"), eq(15432),
- eq(member.getEndpoint().address()), any(), any(), any(), any(), any());
+ eq(started.getDbClusterArn()), any(), anyBoolean(), eq(member.getProxyPort()),
+ eq("127.0.0.1"), eq(15432), eq(member.getEndpoint().address()),
+ any(), any(), any(), any(), any());
}
@Test
@@ -6158,7 +6180,8 @@ class RdsServiceTest {
first.setStatus(DbInstanceStatus.FAILED);
doThrow(new IllegalStateException("temporary member relay error")).doNothing()
.when(proxyManager).startProxy(eq("rds-resource:" + first.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
when(containerManager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))
.thenReturn(new RdsContainerHandle("recovered-container", cluster.getDbClusterArn(),
"retry-cluster", "127.0.0.1", 15432));
@@ -6175,10 +6198,11 @@ class RdsServiceTest {
rdsService.ensureClusterBackend("retry-cluster", "us-east-1");
assertEquals(DbInstanceStatus.STOPPED, stopped.getStatus());
verify(proxyManager, never()).startProxy(eq("rds-resource:" + stopped.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
- verify(proxyManager).startProxy(eq("rds-resource:" + second.getDbInstanceArn()),
- any(), anyBoolean(), eq(second.getProxyPort()), eq("127.0.0.1"), eq(15432),
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
+ verify(proxyManager).startProxy(eq("rds-resource:" + second.getDbInstanceArn()),
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), eq(second.getProxyPort()),
+ eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
verify(containerManager, times(2)).tryStart(eq(cluster.getDbClusterArn()), any(), any(),
any(), any(), any(), any(), any(), any());
}
@@ -6198,10 +6222,12 @@ class RdsServiceTest {
IllegalStateException afterRecoveryFailure = new IllegalStateException("relay failed again");
doThrow(firstFailure).doThrow(firstFailure).doNothing().doThrow(afterRecoveryFailure)
.when(proxyManager).startProxy(eq("rds-resource:" + first.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
doThrow(secondFailure).doThrow(secondFailure).doNothing()
.when(proxyManager).startProxy(eq("rds-resource:" + second.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
when(containerManager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))
.thenReturn(new RdsContainerHandle("log-container", cluster.getDbClusterArn(),
"log-cluster", "127.0.0.1", 15432));
@@ -6239,7 +6265,8 @@ class RdsServiceTest {
IllegalStateException afterRecoveryFailure = new IllegalStateException("relay failed after recovery");
doThrow(firstFailure).doThrow(ongoingFailure).doNothing().doThrow(afterRecoveryFailure)
.when(proxyManager).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
RdsContainerHandle handle = new RdsContainerHandle("restart-log-container",
cluster.getDbClusterArn(), "restart-log-cluster", "127.0.0.1", 15432);
when(containerManager.tryStart(any(), any(), any(), any(), any(), any(), any(), any(), any()))
@@ -6279,7 +6306,8 @@ class RdsServiceTest {
null, null, "dbname", "db.serverless", 0, false, null, null, "control-cluster");
doThrow(new IllegalStateException("temporary member relay error")).doNothing()
.when(proxyManager).startProxy(eq("rds-resource:" + first.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
if (reboot) {
assertThrows(IllegalStateException.class,
() -> rdsService.rebootDbCluster("control-cluster", "us-east-1"));
@@ -6296,7 +6324,8 @@ class RdsServiceTest {
rdsService.ensureClusterBackend("control-cluster", "us-east-1");
assertEquals(DbInstanceStatus.AVAILABLE, first.getStatus());
verify(proxyManager, times(2)).startProxy(eq("rds-resource:" + second.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
verify(containerManager, times(2)).tryStart(eq(cluster.getDbClusterArn()), any(), any(),
any(), any(), any(), any(), any(), any());
}
@@ -6319,7 +6348,7 @@ class RdsServiceTest {
org.mockito.Mockito.doThrow(new IllegalStateException("relay failed"))
.doNothing()
.when(restoredProxyManager).startProxy(
- any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
any(), any(), any(), any(), any(), any());
org.mockito.Mockito.doThrow(new IllegalStateException("restore container cleanup failed"))
.doThrow(new IllegalStateException("delete container cleanup failed"))
@@ -6897,10 +6926,10 @@ class RdsServiceTest {
}).when(proxyManager).stopProxy("db-proxy:" + proxy.getDbProxyArn());
java.util.ArrayList<Boolean> startedModes = new java.util.ArrayList<>();
doAnswer(invocation -> {
- startedModes.add(invocation.getArgument(2));
+ startedModes.add(invocation.getArgument(3));
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
RdsService service = proxyStoreService(
regionResolver, config, proxies, targetGroups, instances, new InMemoryStorage<>());
@@ -6951,10 +6980,10 @@ class RdsServiceTest {
}).when(proxyManager).stopProxy("db-proxy:" + proxy.getDbProxyArn());
java.util.ArrayList<Boolean> startedModes = new java.util.ArrayList<>();
doAnswer(invocation -> {
- startedModes.add(invocation.getArgument(2));
+ startedModes.add(invocation.getArgument(3));
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
RdsService service = proxyStoreService(
regionResolver, config, proxies, targetGroups, instances, new InMemoryStorage<>());
@@ -7220,7 +7249,7 @@ class RdsServiceTest {
doAnswer(invocation -> {
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
RdsService service = proxyStoreService(
regionResolver, config, proxies, targetGroups, instances, new InMemoryStorage<>());
@@ -7337,7 +7366,7 @@ class RdsServiceTest {
doAnswer(invocation -> {
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
RdsService service = proxyStoreService(
regionResolver, config, proxies, targetGroups, instances, new InMemoryStorage<>());
@@ -7406,8 +7435,8 @@ class RdsServiceTest {
assertTrue(targetGroups.get("us-east-1::mysql-proxy").orElseThrow()
.getTargets().isEmpty());
verify(proxyManager).startProxy(
- eq("db-proxy:" + proxy.getDbProxyArn()), eq(DatabaseEngine.MYSQL),
- anyBoolean(), eq(3306), eq("localhost"), eq(3306), any(),
+ eq("db-proxy:" + proxy.getDbProxyArn()), eq(instance.getDbInstanceArn()),
+ eq(DatabaseEngine.MYSQL), anyBoolean(), eq(3306), eq("localhost"), eq(3306), any(),
eq("admin"), eq("secret"), eq("app"), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
verify(proxyManager).stopProxy("db-proxy:" + proxy.getDbProxyArn());
}
@@ -7436,7 +7465,7 @@ class RdsServiceTest {
doAnswer(invocation -> {
relayRunning.set(true);
throw startupFailure;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
doAnswer(invocation -> {
relayRunning.set(false);
@@ -7947,7 +7976,7 @@ class RdsServiceTest {
doAnswer(invocation -> {
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
IllegalStateException deleteFailure =
new IllegalStateException("simulated post-mutation target-group delete failure");
@@ -8012,7 +8041,7 @@ class RdsServiceTest {
doAnswer(invocation -> {
relayRunning.set(true);
return null;
- }).when(proxyManager).startProxy(any(), any(), anyBoolean(), anyInt(), any(),
+ }).when(proxyManager).startProxy(any(), any(), any(), anyBoolean(), anyInt(), any(),
anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
IllegalStateException deleteFailure =
new IllegalStateException("simulated post-mutation proxy delete failure");
@@ -8175,10 +8204,10 @@ class RdsServiceTest {
String relayKeyA = "rds-resource:" + instanceA.getDbInstanceArn();
String relayKeyB = "rds-resource:" + instanceB.getDbInstanceArn();
- verify(proxyManager).startProxy(eq(relayKeyA), any(), anyBoolean(), anyInt(),
- any(), anyInt(), any(), any(), any(), any(), any(), any());
- verify(proxyManager).startProxy(eq(relayKeyB), any(), anyBoolean(), anyInt(),
- any(), anyInt(), any(), any(), any(), any(), any(), any());
+ verify(proxyManager).startProxy(eq(relayKeyA), eq(instanceA.getDbInstanceArn()),
+ any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ verify(proxyManager).startProxy(eq(relayKeyB), eq(instanceB.getDbInstanceArn()),
+ any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
org.mockito.Mockito.clearInvocations(proxyManager);
serviceA.deleteDbInstance("shared-db");
@@ -8293,7 +8322,8 @@ class RdsServiceTest {
assertTrue(rawClusters.get("cluster1").isPresent());
assertTrue(rawClusters.get(currentAccount + "/cluster1").isEmpty());
verify(proxyManager, never()).startProxy(
- any(), any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ any(), any(), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
}
@Test
@@ -8398,8 +8428,9 @@ class RdsServiceTest {
DbProxy failed = service.getDbProxy("mysql-proxy", "us-east-1");
assertEquals("insufficient-resource-limits", failed.getStatus());
verify(proxyManager, never()).startProxy(
- eq("db-proxy:" + proxy.getDbProxyArn()), any(), anyBoolean(), anyInt(),
- any(), anyInt(), any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
+ eq("db-proxy:" + proxy.getDbProxyArn()), any(), any(), anyBoolean(), anyInt(),
+ any(), anyInt(), any(), any(), any(), any(), any(), any(),
+ eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
DbProxy another = service.createDbProxy(
"another-proxy", "MYSQL", true, false, "NONE", PROXY_ROLE_ARN,
@@ -8417,8 +8448,9 @@ class RdsServiceTest {
assertEquals("available",
service.getDbProxy("mysql-proxy", "us-east-1").getStatus());
verify(proxyManager).startProxy(
- eq("db-proxy:" + proxy.getDbProxyArn()), eq(DatabaseEngine.MYSQL),
- anyBoolean(), eq(failed.getProxyPort()), any(), anyInt(),
+ eq("db-proxy:" + proxy.getDbProxyArn()),
+ eq("arn:aws:rds:us-east-1:123456789012:db:mysql-db"),
+ eq(DatabaseEngine.MYSQL), anyBoolean(), eq(failed.getProxyPort()), any(), anyInt(),
any(), any(), any(), any(), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
}
@@ -8444,7 +8476,7 @@ class RdsServiceTest {
assertEquals("available",
service.getDbProxy("app-proxy", "us-east-1").getStatus());
verify(proxyManager, never()).startProxy(
- eq("db-proxy:" + proxy.getDbProxyArn()), any(), anyBoolean(), anyInt(),
+ eq("db-proxy:" + proxy.getDbProxyArn()), any(), any(), anyBoolean(), anyInt(),
any(), anyInt(), any(), any(), any(), any(), any(), any());
}
@@ -8508,8 +8540,8 @@ class RdsServiceTest {
DbProxy restored = restoredService.getDbProxy("app-proxy");
assertEquals("app-proxy", restored.getDbProxyName());
verify(restoredProxyManager).startProxy(eq("db-proxy:" + restored.getDbProxyArn()),
- eq(DatabaseEngine.POSTGRES),
- eq(false), anyInt(), eq("127.0.0.1"), eq(15432), any(),
+ eq("arn:aws:rds:us-east-1:123456789012:cluster:cluster1"),
+ eq(DatabaseEngine.POSTGRES), eq(false), anyInt(), eq("127.0.0.1"), eq(15432), any(),
eq("admin"), eq("secret"), eq("app"), any(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
}
@@ -8580,8 +8612,8 @@ class RdsServiceTest {
ArgumentCaptor<RdsAuthProxy.MasterPasswordCheck> validator =
ArgumentCaptor.forClass(RdsAuthProxy.MasterPasswordCheck.class);
verify(restoredProxyManager).startProxy(eq("db-proxy:" + proxy.getDbProxyArn()),
- eq(DatabaseEngine.POSTGRES),
- eq(false), eq(5432), eq("127.0.0.1"), eq(15432), any(), eq("admin"),
+ eq("arn:aws:rds:us-east-1:" + targetAccount + ":cluster:cluster1"),
+ eq(DatabaseEngine.POSTGRES), eq(false), eq(5432), eq("127.0.0.1"), eq(15432), any(), eq("admin"),
eq("target-secret"), eq("app"), validator.capture(), any(), eq(RdsAuthProxy.EndpointKind.STANDARD_DB_PROXY));
assertTrue(validator.getValue().validate("admin", "target-secret"));
assertFalse(validator.getValue().validate("admin", "default-secret"));
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java
index de7f99a5ef..529b49ae3d 100644
--- a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java
@@ -786,6 +786,68 @@ class RdsContainerManagerTest {
org.mockito.ArgumentMatchers.eq("first-container"), any());
}
+ @Test
+ void resolveBackendEndpointUsesTheActiveRuntimeContainerAndPreferredNetwork() {
+ EmulatorConfig config = config(tempDir.resolve("endpoint-root"));
+ when(config.services().rds().dockerNetwork()).thenReturn(Optional.of("rds-network"));
+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);
+ stubStarts(lifecycleManager, new ContainerLifecycleManager.ContainerInfo(
+ "container-a", Map.of(3306,
+ new ContainerLifecycleManager.EndpointInfo("old-address", 3306))));
+ ContainerLifecycleManager.EndpointInfo currentEndpoint =
+ new ContainerLifecycleManager.EndpointInfo("current-address", 3306);
+ when(lifecycleManager.resolveEndpoint("container-a", 3306, "rds-network"))
+ .thenReturn(currentEndpoint);
+ RdsContainerManager manager = autoPauseManager(config, lifecycleManager);
+ String runtimeId = "arn:aws:rds:us-east-1:000000000000:db:db1";
+ manager.start(runtimeId, "db1", null,
+ DatabaseEngine.MYSQL, "mysql:8.0", "root", "password", "db");
+
+ ContainerLifecycleManager.EndpointInfo resolved =
+ manager.resolveBackendEndpoint(runtimeId, DatabaseEngine.MYSQL);
+
+ assertSame(currentEndpoint, resolved);
+ verify(lifecycleManager).resolveEndpoint("container-a", 3306, "rds-network");
+ verify(lifecycleManager, never()).probeContainer(any());
+ }
+
+ @Test
+ void resolveBackendEndpointUsesTheGlobalDockerNetworkFallback() {
+ EmulatorConfig config = config(tempDir.resolve("global-network-root"));
+ when(config.services().dockerNetwork()).thenReturn(Optional.of("global-network"));
+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);
+ stubStarts(lifecycleManager, new ContainerLifecycleManager.ContainerInfo(
+ "container-a", Map.of(3306,
+ new ContainerLifecycleManager.EndpointInfo("old-address", 3306))));
+ ContainerLifecycleManager.EndpointInfo currentEndpoint =
+ new ContainerLifecycleManager.EndpointInfo("current-address", 3306);
+ when(lifecycleManager.resolveEndpoint("container-a", 3306, "global-network"))
+ .thenReturn(currentEndpoint);
+ RdsContainerManager manager = autoPauseManager(config, lifecycleManager);
+ String runtimeId = "arn:aws:rds:us-east-1:000000000000:db:db1";
+ manager.start(runtimeId, "db1", null,
+ DatabaseEngine.MYSQL, "mysql:8.0", "root", "password", "db");
+
+ ContainerLifecycleManager.EndpointInfo resolved =
+ manager.resolveBackendEndpoint(runtimeId, DatabaseEngine.MYSQL);
+
+ assertSame(currentEndpoint, resolved);
+ verify(lifecycleManager).resolveEndpoint("container-a", 3306, "global-network");
+ }
+
+ @Test
+ void resolveBackendEndpointFailsWhenRuntimeIsInactive() {
+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);
+ RdsContainerManager manager = daemonlessCapableManager(lifecycleManager);
+
+ IllegalStateException failure = assertThrows(IllegalStateException.class,
+ () -> manager.resolveBackendEndpoint(
+ "arn:aws:rds:us-east-1:000000000000:db:missing",
+ DatabaseEngine.POSTGRES));
+
+ assertTrue(failure.getMessage().contains("has no active container"));
+ }
+
private RdsContainerManager daemonlessCapableManager(ContainerLifecycleManager lifecycleManager) {
EmulatorConfig config = config(tempDir.resolve("host-root"));
ContainerLogStreamer logStreamer = mock(ContainerLogStreamer.class);
@@ -1276,7 +1338,7 @@ class RdsContainerManagerTest {
verify(pause).exec();
assertThrows(RdsBackendGate.ResumingException.class, () -> manager.enter("db1", 3306, false));
- manager.enter("db1", 3306).close();
+ manager.enterRuntime(runtimeId).close();
verify(unpause).exec();
assertTrue(manager.pauseIfIdle(runtimeId));
@@ -1285,6 +1347,7 @@ class RdsContainerManagerTest {
order.verify(unpause, times(2)).exec();
order.verify(lifecycleManager).stopAndRemoveStrict(eq("cluster-container"), any());
assertSame(RdsBackendGate.Lease.NONE, manager.enter("db1", 3306));
+ assertSame(RdsBackendGate.Lease.NONE, manager.enterRuntime(runtimeId));
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java
new file mode 100644
index 0000000000..9e1ea0da15
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsAuthProxyBackendResolutionTest.java
@@ -0,0 +1,209 @@
+package io.github.hectorvent.floci.services.rds.proxy;
+
+import io.github.hectorvent.floci.services.rds.container.RdsBackendGate;
+import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;
+import io.github.hectorvent.floci.testutil.FreePorts;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+class RdsAuthProxyBackendResolutionTest {
+
+ private final List<RdsAuthProxy> proxies = new ArrayList<>();
+ private final List<ServerSocket> backends = new ArrayList<>();
+
+ @AfterEach
+ void tearDown() throws IOException {
+ for (RdsAuthProxy proxy : proxies) {
+ proxy.stop();
+ }
+ for (ServerSocket backend : backends) {
+ if (!backend.isClosed()) {
+ backend.close();
+ }
+ }
+ }
+
+ @Test
+ void keepsEachProxyConnectedToItsBackendWhenAddressesSwap() throws Exception {
+ ServerSocket firstAddress = backendAt(0);
+ ServerSocket secondAddress = backendAt(0);
+ int firstPort = firstAddress.getLocalPort();
+ int secondPort = secondAddress.getLocalPort();
+ AtomicReference<RdsAuthProxy.BackendEndpoint> firstEndpoint = new AtomicReference<>(
+ endpoint(firstPort));
+ AtomicReference<RdsAuthProxy.BackendEndpoint> secondEndpoint = new AtomicReference<>(
+ endpoint(secondPort));
+ int[] proxyPorts = FreePorts.anyInterfacePorts(2);
+ int firstProxyPort = proxyPorts[0];
+ int secondProxyPort = proxyPorts[1];
+ RdsAuthProxy firstProxy = proxy("db-a", firstPort, firstEndpoint::get);
+ RdsAuthProxy secondProxy = proxy("db-b", secondPort, secondEndpoint::get);
+ firstProxy.start(firstProxyPort);
+ secondProxy.start(secondProxyPort);
+
+ assertEquals('a', connectAndRead(firstProxyPort, firstAddress, 'a'));
+ assertEquals('b', connectAndRead(secondProxyPort, secondAddress, 'b'));
+
+ firstAddress.close();
+ secondAddress.close();
+ ServerSocket secondDatabaseAtFirstAddress = backendAt(firstPort);
+ ServerSocket firstDatabaseAtSecondAddress = backendAt(secondPort);
+ firstEndpoint.set(endpoint(secondPort));
+ secondEndpoint.set(endpoint(firstPort));
+
+ assertEquals('a', connectAndRead(
+ firstProxyPort, firstDatabaseAtSecondAddress, 'a'));
+ assertEquals('b', connectAndRead(
+ secondProxyPort, secondDatabaseAtFirstAddress, 'b'));
+ }
+
+ @Test
+ void usesLatestEndpointWhenPreviousAddressIsUnused() throws Exception {
+ ServerSocket previousAddress = backendAt(0);
+ int previousPort = previousAddress.getLocalPort();
+ AtomicReference<RdsAuthProxy.BackendEndpoint> endpoint = new AtomicReference<>(
+ endpoint(previousPort));
+ int proxyPort = FreePorts.anyInterfacePort();
+ RdsAuthProxy proxy = proxy("db-a", previousPort, endpoint::get);
+ proxy.start(proxyPort);
+ assertEquals('a', connectAndRead(proxyPort, previousAddress, 'a'));
+
+ previousAddress.close();
+ ServerSocket currentAddress = backendAt(0);
+ endpoint.set(endpoint(currentAddress.getLocalPort()));
+
+ assertEquals('a', connectAndRead(proxyPort, currentAddress, 'a'));
+ }
+
+ @Test
+ void doesNotFallBackToStaleEndpointWhenResolutionFails() throws Exception {
+ ServerSocket staleAddress = backendAt(0);
+ staleAddress.setSoTimeout(500);
+ int proxyPort = FreePorts.anyInterfacePort();
+ RdsAuthProxy proxy = proxy("db-a", staleAddress.getLocalPort(),
+ () -> {
+ throw new IOException("Docker inspect failed");
+ });
+ proxy.start(proxyPort);
+
+ try (Socket client = new Socket("127.0.0.1", proxyPort)) {
+ client.setSoTimeout(5000);
+ assertEquals(-1, client.getInputStream().read());
+ }
+ assertThrows(SocketTimeoutException.class, staleAddress::accept,
+ "the proxy fell back to the stale backend address");
+ }
+
+ @Test
+ void postgresReportsConnectionFailureWhenEndpointResolutionFails() throws Exception {
+ int proxyPort = FreePorts.anyInterfacePort();
+ RdsAuthProxy proxy = proxy("db-a", 1,
+ () -> {
+ throw new IOException("Docker inspect failed");
+ }, DatabaseEngine.POSTGRES);
+ proxy.start(proxyPort);
+
+ try (Socket client = new Socket("127.0.0.1", proxyPort)) {
+ client.setSoTimeout(5000);
+ ByteArrayOutputStream startup = new ByteArrayOutputStream();
+ DataOutputStream fields = new DataOutputStream(startup);
+ fields.writeInt(196608);
+ fields.writeBytes("user");
+ fields.writeByte(0);
+ fields.writeBytes("admin");
+ fields.writeByte(0);
+ fields.writeBytes("database");
+ fields.writeByte(0);
+ fields.writeBytes("app");
+ fields.writeByte(0);
+ fields.writeByte(0);
+ DataOutputStream request = new DataOutputStream(client.getOutputStream());
+ request.writeInt(startup.size() + 4);
+ startup.writeTo(request);
+ request.flush();
+
+ DataInputStream response = new DataInputStream(client.getInputStream());
+ assertEquals('R', response.readUnsignedByte());
+ assertEquals(8, response.readInt());
+ assertEquals(3, response.readInt());
+ byte[] password = "Secret123\0".getBytes(StandardCharsets.UTF_8);
+ request.writeByte('p');
+ request.writeInt(password.length + 4);
+ request.write(password);
+ request.flush();
+
+ assertEquals('E', response.readUnsignedByte());
+ byte[] errorFields = response.readNBytes(response.readInt() - 4);
+ String error = new String(errorFields, StandardCharsets.UTF_8);
+ assertTrue(error.contains("C08006"));
+ assertTrue(error.contains("Mcould not connect to backend database"));
+ }
+ }
+
+ private RdsAuthProxy proxy(String id, int initialBackendPort,
+ RdsAuthProxy.BackendEndpointResolver endpointResolver) {
+ return proxy(id, initialBackendPort, endpointResolver, DatabaseEngine.SQLSERVER);
+ }
+
+ private RdsAuthProxy proxy(String id, int initialBackendPort,
+ RdsAuthProxy.BackendEndpointResolver endpointResolver,
+ DatabaseEngine engine) {
+ RdsAuthProxy proxy = new RdsAuthProxy(
+ id, "127.0.0.1", initialBackendPort, endpointResolver,
+ engine, false, "sa", "Secret123", null,
+ mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class),
+ (user, password) -> true, 5000, 5000, 100, null,
+ username -> false, RdsBackendGate.OPEN, RdsAuthProxy.EndpointKind.DATABASE);
+ proxies.add(proxy);
+ return proxy;
+ }
+
+ private ServerSocket backendAt(int port) throws IOException {
+ ServerSocket backend = new ServerSocket();
+ backend.setReuseAddress(true);
+ backend.bind(new InetSocketAddress("127.0.0.1", port));
+ backends.add(backend);
+ return backend;
+ }
+
+ private static RdsAuthProxy.BackendEndpoint endpoint(int port) {
+ return new RdsAuthProxy.BackendEndpoint("127.0.0.1", port);
+ }
+
+ private static int connectAndRead(int proxyPort, ServerSocket backend, int marker)
+ throws Exception {
+ Thread serving = Thread.ofVirtual().start(() -> {
+ try (Socket accepted = backend.accept()) {
+ accepted.getOutputStream().write(marker);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ });
+ int received;
+ try (Socket client = new Socket("127.0.0.1", proxyPort)) {
+ client.setSoTimeout(5000);
+ received = client.getInputStream().read();
+ }
+ assertTrue(serving.join(Duration.ofSeconds(5)), "fake backend did not finish serving");
+ return received;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsBackendEndpointRefreshIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsBackendEndpointRefreshIntegrationTest.java
new file mode 100644
index 0000000000..3026716765
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsBackendEndpointRefreshIntegrationTest.java
@@ -0,0 +1,313 @@
+package io.github.hectorvent.floci.services.rds.proxy;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.command.CreateContainerResponse;
+import com.github.dockerjava.api.command.CreateNetworkResponse;
+import com.github.dockerjava.api.exception.DockerException;
+import com.github.dockerjava.api.model.ContainerNetwork;
+import com.github.dockerjava.api.model.ExposedPort;
+import com.github.dockerjava.api.model.HostConfig;
+import com.github.dockerjava.api.model.Network;
+import com.github.dockerjava.core.DefaultDockerClientConfig;
+import com.github.dockerjava.core.DockerClientImpl;
+import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
+import io.github.hectorvent.floci.core.common.docker.ContainerExec;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;
+import io.github.hectorvent.floci.services.lambda.launcher.ImageCacheService;
+import io.github.hectorvent.floci.services.rds.container.RdsBackendGate;
+import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;
+import io.github.hectorvent.floci.testutil.FreePorts;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@Tag("docker")
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class RdsBackendEndpointRefreshIntegrationTest {
+
+ private static final String IMAGE = "postgres:16-alpine";
+ private static final String USER = "admin";
+ private static final String PASSWORD = "password123";
+ private static final String DATABASE = "appdb";
+ private static final int POSTGRES_PORT = 5432;
+
+ private final List<RdsAuthProxy> proxies = new ArrayList<>();
+ private DockerClient dockerClient;
+ private ContainerLifecycleManager lifecycleManager;
+ private String networkId;
+ private String networkName;
+ private String firstContainerId;
+ private String secondContainerId;
+ private String firstAddress;
+ private String secondAddress;
+
+ @BeforeAll
+ void connectToDocker() {
+ try {
+ DefaultDockerClientConfig clientConfig = DefaultDockerClientConfig
+ .createDefaultConfigBuilder()
+ .build();
+ ApacheDockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
+ .dockerHost(clientConfig.getDockerHost())
+ .maxConnections(10)
+ .connectionTimeout(Duration.ofSeconds(10))
+ .responseTimeout(Duration.ofMinutes(5))
+ .build();
+ dockerClient = DockerClientImpl.getInstance(clientConfig, httpClient);
+ dockerClient.pingCmd().exec();
+ dockerClient.pullImageCmd(IMAGE).start().awaitCompletion(120, TimeUnit.SECONDS);
+ } catch (Exception e) {
+ assumeTrue(false, "Docker or " + IMAGE + " is not available: " + e.getMessage());
+ }
+
+ ContainerDetector detector = mock(ContainerDetector.class);
+ when(detector.isRunningInContainer()).thenReturn(true);
+ lifecycleManager = new ContainerLifecycleManager(
+ dockerClient, mock(ImageCacheService.class), detector, mock(EmulatorConfig.class));
+ }
+
+ @AfterAll
+ void closeDocker() throws IOException {
+ if (dockerClient != null) {
+ dockerClient.close();
+ }
+ }
+
+ @BeforeEach
+ void startBackends() {
+ networkName = "floci-rds-endpoint-refresh-" + UUID.randomUUID();
+ CreateNetworkResponse network = dockerClient.createNetworkCmd()
+ .withName(networkName)
+ .withIpam(new Network.Ipam().withConfig(
+ new Network.Ipam.Config().withSubnet("198.18.200.0/24")))
+ .exec();
+ networkId = network.getId();
+ firstContainerId = startPostgres("first");
+ secondContainerId = startPostgres("second");
+ waitForPostgres(firstContainerId);
+ waitForPostgres(secondContainerId);
+ firstAddress = containerAddress(firstContainerId);
+ secondAddress = containerAddress(secondContainerId);
+ assertNotEquals(firstAddress, secondAddress);
+ assumeTrue(canConnectEventually(firstAddress, POSTGRES_PORT)
+ && canConnectEventually(secondAddress, POSTGRES_PORT),
+ "Docker bridge addresses are not reachable from this test JVM");
+ }
+
+ @AfterEach
+ void tearDown() {
+ for (RdsAuthProxy proxy : proxies) {
+ proxy.stop();
+ }
+ proxies.clear();
+ removeContainer(firstContainerId);
+ removeContainer(secondContainerId);
+ if (networkId != null) {
+ try {
+ dockerClient.removeNetworkCmd(networkId).exec();
+ } catch (DockerException ignored) {
+ // best effort
+ }
+ }
+ firstContainerId = null;
+ secondContainerId = null;
+ networkId = null;
+ }
+
+ @Test
+ void proxyPortsKeepTheirInstancesAfterContainerAddressesSwap() throws Exception {
+ int[] proxyPorts = FreePorts.anyInterfacePorts(2);
+ RdsAuthProxy firstProxy = proxy("first", firstContainerId, firstAddress);
+ RdsAuthProxy secondProxy = proxy("second", secondContainerId, secondAddress);
+ firstProxy.start(proxyPorts[0]);
+ secondProxy.start(proxyPorts[1]);
+ String firstSystemIdentifier = systemIdentifier(proxyPorts[0]);
+ String secondSystemIdentifier = systemIdentifier(proxyPorts[1]);
+ assertNotEquals(firstSystemIdentifier, secondSystemIdentifier);
+
+ stopAndDisconnect(firstContainerId);
+ stopAndDisconnect(secondContainerId);
+ connect(firstContainerId, secondAddress);
+ connect(secondContainerId, firstAddress);
+ dockerClient.startContainerCmd(secondContainerId).exec();
+ dockerClient.startContainerCmd(firstContainerId).exec();
+ waitForPostgres(firstContainerId);
+ waitForPostgres(secondContainerId);
+ assertEquals(secondAddress, containerAddress(firstContainerId));
+ assertEquals(firstAddress, containerAddress(secondContainerId));
+
+ assertEquals(firstSystemIdentifier, systemIdentifier(proxyPorts[0]));
+ assertEquals(secondSystemIdentifier, systemIdentifier(proxyPorts[1]));
+ }
+
+ @Test
+ void proxyUsesRestartedContainerWhenItsPreviousAddressIsUnused() throws Exception {
+ int proxyPort = FreePorts.anyInterfacePort();
+ RdsAuthProxy proxy = proxy("first", firstContainerId, firstAddress);
+ proxy.start(proxyPort);
+ String systemIdentifier = systemIdentifier(proxyPort);
+
+ stopAndDisconnect(firstContainerId);
+ stopAndDisconnect(secondContainerId);
+ connect(firstContainerId, secondAddress);
+ dockerClient.startContainerCmd(firstContainerId).exec();
+ waitForPostgres(firstContainerId);
+ assertEquals(secondAddress, containerAddress(firstContainerId));
+ assertFalse(canConnect(firstAddress, POSTGRES_PORT),
+ "the stale backend address must be unused in this scenario");
+
+ assertEquals(systemIdentifier, systemIdentifier(proxyPort));
+ }
+
+ private RdsAuthProxy proxy(String id, String containerId, String initialAddress) {
+ RdsAuthProxy.BackendEndpointResolver resolver = () -> {
+ ContainerLifecycleManager.EndpointInfo endpoint = lifecycleManager.resolveEndpoint(
+ containerId, POSTGRES_PORT, networkName);
+ return new RdsAuthProxy.BackendEndpoint(endpoint.host(), endpoint.port());
+ };
+ RdsAuthProxy proxy = new RdsAuthProxy(
+ id, initialAddress, POSTGRES_PORT, resolver, DatabaseEngine.POSTGRES, false,
+ USER, PASSWORD, DATABASE, mock(RdsSigV4Validator.class),
+ mock(RdsProxyTlsCertificates.class), (user, password) -> true,
+ 5000, 5000, 100, null, username -> false,
+ RdsBackendGate.OPEN, RdsAuthProxy.EndpointKind.DATABASE);
+ proxies.add(proxy);
+ return proxy;
+ }
+
+ private String startPostgres(String suffix) {
+ CreateContainerResponse container = dockerClient.createContainerCmd(IMAGE)
+ .withName(networkName + "-" + suffix)
+ .withExposedPorts(ExposedPort.tcp(POSTGRES_PORT))
+ .withHostConfig(HostConfig.newHostConfig().withNetworkMode(networkName))
+ .withEnv(
+ "POSTGRES_USER=" + USER,
+ "POSTGRES_PASSWORD=" + PASSWORD,
+ "POSTGRES_DB=" + DATABASE)
+ .exec();
+ dockerClient.startContainerCmd(container.getId()).exec();
+ return container.getId();
+ }
+
+ private void stopAndDisconnect(String containerId) {
+ dockerClient.stopContainerCmd(containerId).withTimeout(10).exec();
+ dockerClient.disconnectFromNetworkCmd()
+ .withContainerId(containerId)
+ .withNetworkId(networkId)
+ .exec();
+ }
+
+ private void connect(String containerId, String address) {
+ dockerClient.connectToNetworkCmd()
+ .withContainerId(containerId)
+ .withNetworkId(networkId)
+ .withContainerNetwork(new ContainerNetwork().withIpamConfig(
+ new ContainerNetwork.Ipam().withIpv4Address(address)))
+ .exec();
+ }
+
+ private String containerAddress(String containerId) {
+ return dockerClient.inspectContainerCmd(containerId).exec()
+ .getNetworkSettings().getNetworks().get(networkName).getIpAddress();
+ }
+
+ private String systemIdentifier(int proxyPort) throws Exception {
+ Class.forName("org.postgresql.Driver");
+ Properties properties = new Properties();
+ properties.setProperty("user", USER);
+ properties.setProperty("password", PASSWORD);
+ properties.setProperty("sslmode", "disable");
+ try (Connection connection = DriverManager.getConnection(
+ "jdbc:postgresql://127.0.0.1:" + proxyPort + "/" + DATABASE, properties);
+ Statement statement = connection.createStatement();
+ ResultSet result = statement.executeQuery(
+ "SELECT system_identifier::text FROM pg_control_system()")) {
+ assertTrue(result.next());
+ return result.getString(1);
+ }
+ }
+
+ private void waitForPostgres(String containerId) {
+ String[] command = {"pg_isready", "-U", USER, "-d", DATABASE};
+ ContainerExec.Result lastResult = null;
+ for (int attempt = 0; attempt < 60; attempt++) {
+ lastResult = ContainerExec.run(dockerClient, containerId, command, 5);
+ if (lastResult.exitCode() == 0) {
+ return;
+ }
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new IllegalStateException("Interrupted waiting for PostgreSQL", e);
+ }
+ }
+ throw new IllegalStateException(
+ "PostgreSQL did not become ready in container " + containerId
+ + "; last pg_isready exit=" + lastResult.exitCode()
+ + ", stderr=" + lastResult.stderr());
+ }
+
+ private static boolean canConnectEventually(String host, int port) {
+ for (int attempt = 0; attempt < 20; attempt++) {
+ if (canConnect(host, port)) {
+ return true;
+ }
+ try {
+ Thread.sleep(250);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ return false;
+ }
+ }
+ return false;
+ }
+
+ private static boolean canConnect(String host, int port) {
+ try (Socket socket = new Socket()) {
+ socket.connect(new InetSocketAddress(host, port), 1000);
+ return true;
+ } catch (IOException e) {
+ return false;
+ }
+ }
+
+ private void removeContainer(String containerId) {
+ if (containerId == null) {
+ return;
+ }
+ try {
+ dockerClient.removeContainerCmd(containerId).withForce(true).exec();
+ } catch (DockerException ignored) {
+ // best effort
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManagerTest.java
index d88e26d823..d011f05ece 100644
--- a/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManagerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/proxy/RdsProxyManagerTest.java
@@ -1,8 +1,12 @@
package io.github.hectorvent.floci.services.rds.proxy;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;
+import io.github.hectorvent.floci.services.rds.container.RdsBackendGate;
+import io.github.hectorvent.floci.services.rds.container.RdsContainerManager;
import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;
import io.github.hectorvent.floci.testutil.FreePorts;
+import io.github.hectorvent.floci.testutil.LogCapture;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
@@ -14,10 +18,13 @@ import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.Duration;
+import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -27,16 +34,19 @@ import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
class RdsProxyManagerTest {
@Test
void interruptedRetirementRetainsOwnershipAndCanBeRetried() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
RdsAuthProxy proxy = authProxy("proxy");
CountDownLatch release = new CountDownLatch(1);
Thread accepting = blockedRetirement(release);
@@ -77,8 +87,7 @@ class RdsProxyManagerTest {
@Test
void retirementTimeoutRetainsOwnershipAndCanBeRetried() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
RdsAuthProxy proxy = authProxy("proxy");
proxy.acceptRetirementTimeout = Duration.ofMillis(10);
CountDownLatch release = new CountDownLatch(1);
@@ -106,8 +115,7 @@ class RdsProxyManagerTest {
@Test
void samePortRebootDoesNotWaitForASeparateReleasePoll() throws IOException {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int port = FreePorts.anyInterfacePort();
try {
for (int attempt = 0; attempt < 100; attempt++) {
@@ -148,8 +156,7 @@ class RdsProxyManagerTest {
@Test
void replacingProxyStopsPreviousListenerAndKeepsReplacementOwned() throws IOException {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int firstPort = FreePorts.anyInterfacePort();
try {
start(manager, "proxy", firstPort);
@@ -168,8 +175,7 @@ class RdsProxyManagerTest {
@Test
void registrationFailureAfterBindReleasesCandidateListener() throws IOException {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int proxyPort = FreePorts.anyInterfacePort();
try {
assertThrows(RuntimeException.class, () -> start(manager, null, proxyPort));
@@ -182,8 +188,7 @@ class RdsProxyManagerTest {
@Test
void failedReplacementPreservesOriginalRegistryEntry() throws IOException {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int originalPort = FreePorts.anyInterfacePort();
try {
start(manager, "proxy", originalPort);
@@ -202,8 +207,7 @@ class RdsProxyManagerTest {
@Test
void updateMasterPasswordSwapsTheRunningProxySnapshotWithoutARestart() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int proxyPort = FreePorts.anyInterfacePort();
try {
start(manager, "proxy", proxyPort);
@@ -219,16 +223,14 @@ class RdsProxyManagerTest {
@Test
void updateMasterPasswordForUnknownInstanceIsANoOp() {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
assertDoesNotThrow(() -> manager.updateMasterPassword("missing", "rotated"));
}
@Test
void stopAllReleasesEveryListenerAndIsIdempotent() throws IOException {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int firstPort = FreePorts.anyInterfacePort();
start(manager, "first", firstPort);
int secondPort = FreePorts.anyInterfacePort();
@@ -243,8 +245,7 @@ class RdsProxyManagerTest {
@Test
void closeFailurePropagatesAndManagerRetainsOwnership() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
RdsAuthProxy proxy = authProxy("proxy");
ServerSocket serverSocket = mock(ServerSocket.class);
IOException closeFailure = new IOException("simulated close failure");
@@ -263,8 +264,7 @@ class RdsProxyManagerTest {
@Test
void failedPreviousStopRestoresMappingAndReleasesCandidate() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
RdsAuthProxy previous = mock(RdsAuthProxy.class);
doThrow(new IllegalStateException("simulated previous stop failure"))
.when(previous).stop();
@@ -281,8 +281,7 @@ class RdsProxyManagerTest {
@Test
void stopAllContinuesAndRetainsOnlyFailedListenerOwnership() throws Exception {
- RdsProxyManager manager = new RdsProxyManager(
- mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class), testConfig());
+ RdsProxyManager manager = manager();
int successfulPort = FreePorts.anyInterfacePort();
start(manager, "successful", successfulPort);
RdsAuthProxy failed = mock(RdsAuthProxy.class);
@@ -299,8 +298,105 @@ class RdsProxyManagerTest {
registry.clear();
}
+ @Test
+ void endpointResolutionWarningIsLoggedOnceUntilResolutionRecovers() throws Exception {
+ RdsContainerManager containerManager = mock(RdsContainerManager.class);
+ String runtimeId = "arn:aws:rds:us-east-1:123456789012:db:db-a";
+ IllegalStateException resolutionFailure = new IllegalStateException("Docker unavailable");
+ when(containerManager.resolveBackendEndpoint(runtimeId, DatabaseEngine.SQLSERVER))
+ .thenThrow(resolutionFailure)
+ .thenThrow(resolutionFailure)
+ .thenReturn(new EndpointInfo("127.0.0.1", 1433))
+ .thenThrow(resolutionFailure);
+ RdsProxyManager manager = new RdsProxyManager(
+ mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class),
+ testConfig(), RdsBackendGate.OPEN, containerManager);
+ try {
+ manager.startProxy("proxy", runtimeId, DatabaseEngine.SQLSERVER, false,
+ FreePorts.anyInterfacePort(), "stale-address", 1, "localhost",
+ "sa", "secret", null, (user, password) -> true, null);
+ RdsAuthProxy.BackendEndpointResolver resolver = endpointResolver(
+ registry(manager).get("proxy"));
+
+ List<LogRecord> records = LogCapture.capture(RdsProxyManager.class, () -> {
+ assertThrows(IOException.class, resolver::resolve);
+ assertThrows(IOException.class, resolver::resolve);
+ assertDoesNotThrow(resolver::resolve);
+ assertThrows(IOException.class, resolver::resolve);
+ });
+
+ List<LogRecord> warnings = records.stream()
+ .filter(record -> record.getLevel().intValue() >= Level.WARNING.intValue())
+ .toList();
+ assertEquals(2, warnings.size());
+ assertTrue(warnings.stream().allMatch(record ->
+ record.getMessage().contains("Could not resolve backend endpoint")));
+ assertTrue(warnings.stream().allMatch(record ->
+ runtimeId.equals(record.getParameters()[0])));
+ assertSame(resolutionFailure, warnings.getFirst().getThrown());
+ } finally {
+ manager.stopAll();
+ }
+ }
+
+ @Test
+ void dynamicProxyResolvesTheBackendForEveryConnection() throws Exception {
+ RdsContainerManager containerManager = mock(RdsContainerManager.class);
+ RdsBackendGate backendGate = mock(RdsBackendGate.class);
+ String runtimeId = "arn:aws:rds:us-east-1:123456789012:db:db-a";
+ when(backendGate.enterRuntime(runtimeId)).thenReturn(RdsBackendGate.Lease.NONE);
+ try (ServerSocket backend = reusableSocket(0)) {
+ when(containerManager.resolveBackendEndpoint(runtimeId, DatabaseEngine.SQLSERVER))
+ .thenReturn(new EndpointInfo("127.0.0.1", backend.getLocalPort()));
+ RdsProxyManager manager = new RdsProxyManager(
+ mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class),
+ testConfig(), backendGate, containerManager);
+ int proxyPort = FreePorts.anyInterfacePort();
+ Thread serving = Thread.ofVirtual().start(() -> {
+ try {
+ for (int connection = 0; connection < 2; connection++) {
+ try (Socket accepted = backend.accept()) {
+ accepted.getOutputStream().write('x');
+ }
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ });
+ try {
+ manager.startProxy("proxy", runtimeId, DatabaseEngine.SQLSERVER, false,
+ proxyPort, "stale-address", 1, "localhost", "sa", "secret", null,
+ (user, password) -> true, null);
+
+ for (int connection = 0; connection < 2; connection++) {
+ try (Socket client = new Socket("127.0.0.1", proxyPort)) {
+ client.setSoTimeout(5000);
+ assertEquals('x', client.getInputStream().read());
+ }
+ }
+
+ assertTrue(serving.join(Duration.ofSeconds(5)));
+ verify(containerManager, times(2))
+ .resolveBackendEndpoint(runtimeId, DatabaseEngine.SQLSERVER);
+ verify(backendGate, times(2)).enterRuntime(runtimeId);
+ } finally {
+ manager.stopAll();
+ }
+ }
+ }
+
+ private static RdsProxyManager manager() {
+ RdsContainerManager containerManager = mock(RdsContainerManager.class);
+ when(containerManager.resolveBackendEndpoint(
+ anyString(), any(DatabaseEngine.class)))
+ .thenReturn(new EndpointInfo("localhost", 1));
+ return new RdsProxyManager(
+ mock(RdsSigV4Validator.class), mock(RdsProxyTlsCertificates.class),
+ testConfig(), RdsBackendGate.OPEN, containerManager);
+ }
+
private static void start(RdsProxyManager manager, String key, int proxyPort) {
- manager.startProxy(key, DatabaseEngine.POSTGRES, false, proxyPort,
+ manager.startProxy(key, "runtime:" + key, DatabaseEngine.POSTGRES, false, proxyPort,
"localhost", 1, "localhost", "admin", "secret", "app", (user, password) -> true,
new RdsProxyBinding("localhost", proxyPort, "us-east-1", "123456789012", "db-ABCDEFGHIJKL01234", true));
}
@@ -324,6 +420,13 @@ class RdsProxyManagerTest {
return config;
}
+ private static RdsAuthProxy.BackendEndpointResolver endpointResolver(RdsAuthProxy proxy)
+ throws Exception {
+ Field field = RdsAuthProxy.class.getDeclaredField("backendEndpointResolver");
+ field.setAccessible(true);
+ return (RdsAuthProxy.BackendEndpointResolver) field.get(proxy);
+ }
+
private static String masterPassword(RdsAuthProxy proxy) throws Exception {
Field field = RdsAuthProxy.class.getDeclaredField("masterPassword");
field.setAccessible(true);
diff --git a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataResourceResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataResourceResolverTest.java
index 1f61f94085..1a1608273c 100644
--- a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataResourceResolverTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataResourceResolverTest.java
@@ -150,7 +150,8 @@ class RdsDataResourceResolverTest {
instances.put("stopped-member", stoppedMember);
doThrow(new IllegalStateException("temporary member relay error")).doNothing()
.when(proxies).startProxy(eq("rds-resource:" + retryMember.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), anyInt(), any(), anyInt(),
+ any(), any(), any(), any(), any(), any());
RdsDataResourceResolver resolver = new RdsDataResourceResolver(rdsService);
RdsDataResourceResolver.DatabaseTarget firstTarget = resolver.resolve(cluster.getDbClusterArn(), "us-west-2");
@@ -170,13 +171,15 @@ class RdsDataResourceResolverTest {
assertEquals(DbInstanceStatus.STOPPED, stoppedMember.getStatus());
verify(rdsService, times(2)).ensureClusterBackend("cluster1", "us-west-2");
verify(proxies, times(2)).startProxy(eq("rds-resource:" + retryMember.getDbInstanceArn()),
- any(), anyBoolean(), eq(7002), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), eq(7002), eq("127.0.0.1"),
+ eq(15432), any(), any(), any(), any(), any(), any());
verify(proxies).startProxy(eq("rds-resource:" + otherMember.getDbInstanceArn()),
- any(), anyBoolean(), eq(7003), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq(cluster.getDbClusterArn()), any(), anyBoolean(), eq(7003), eq("127.0.0.1"),
+ eq(15432), any(), any(), any(), any(), any(), any());
verify(proxies, never()).startProxy(eq("rds-resource:" + stoppedMember.getDbInstanceArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ any(), any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
verify(proxies, never()).startProxy(eq("rds-resource:" + cluster.getDbClusterArn()),
- any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
+ any(), any(), anyBoolean(), anyInt(), any(), anyInt(), any(), any(), any(), any(), any(), any());
verifyNoInteractions(fixture.containers());
}
@@ -226,7 +229,8 @@ class RdsDataResourceResolverTest {
assertEquals(15432, member.getContainerPort());
verify(fixture.service()).ensureClusterBackend("cluster1", "us-west-2");
verify(fixture.proxies()).startProxy(eq("rds-resource:" + member.getDbInstanceArn()),
- any(), anyBoolean(), eq(7002), eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
+ eq(fixture.cluster().getDbClusterArn()), any(), anyBoolean(), eq(7002),
+ eq("127.0.0.1"), eq(15432), any(), any(), any(), any(), any(), any());
verifyNoInteractions(fixture.containers());
}