diff --git a/google-cloud-spanner-cassandra/src/main/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilder.java b/google-cloud-spanner-cassandra/src/main/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilder.java index ae6f1706..529373ee 100644 --- a/google-cloud-spanner-cassandra/src/main/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilder.java +++ b/google-cloud-spanner-cassandra/src/main/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilder.java @@ -19,9 +19,13 @@ import com.datastax.oss.driver.api.core.CqlSession; import com.datastax.oss.driver.api.core.config.DefaultDriverOption; import com.datastax.oss.driver.api.core.config.DriverConfigLoader; +import com.datastax.oss.driver.api.core.context.DriverContext; import com.datastax.oss.driver.api.core.metadata.EndPoint; +import com.datastax.oss.driver.api.core.session.ProgrammaticArguments; import com.datastax.oss.driver.api.core.session.SessionBuilder; +import com.datastax.oss.driver.internal.core.context.DefaultDriverContext; import com.datastax.oss.driver.internal.core.metadata.DefaultEndPoint; +import com.datastax.oss.driver.internal.core.metadata.MetadataManager; import com.google.api.gax.rpc.TransportChannelProvider; import com.google.auth.Credentials; import com.google.cloud.spanner.adapter.metrics.BuiltInMetricsProvider; @@ -31,6 +35,7 @@ import com.google.common.net.HostAndPort; import com.google.spanner.adapter.v1.DatabaseName; import io.opentelemetry.api.OpenTelemetry; +import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.SocketAddress; @@ -241,14 +246,70 @@ public CompletionStage buildAsync() { CompletableFuture adapterStartFuture = CompletableFuture.runAsync(this::createAndStartAdapter); - // After the Adapter starts, build the CQL session. + // After the Adapter starts, build the CQL session. If session initialization fails, stop the + // started Adapter so its ServerSocket, gRPC channels, and executor threads do not leak. return adapterStartFuture.thenCompose( v -> { LOG.info("Creating CQL session for database URI: {}", databaseUri); - return super.buildAsync(); + final Adapter startedAdapter = this.adapter; + final CompletionStage sessionFuture; + try { + sessionFuture = super.buildAsync(); + } catch (Throwable t) { + stopAdapterQuietly(startedAdapter); + throw t; + } + return sessionFuture.whenComplete( + (session, error) -> { + if (error != null) { + stopAdapterQuietly(startedAdapter); + } + }); }); } + /** + * Builds the {@link DriverContext} for this session. + * + *

When no contact point was explicitly supplied by the caller, {@link #createAndStartAdapter} + * registers the OS-assigned ephemeral loopback endpoint in {@code programmaticContactPoints}, + * which would otherwise cause {@link MetadataManager#wasImplicitContactPoint()} to return {@code + * false}. Returning {@code true} here preserves pre-ephemeral-port driver behavior: explicit + * programmatic or config-supplied local datacenters take precedence, while zero-configuration + * callers (including named profiles) still infer the local datacenter from the server. + */ + @Override + protected DriverContext buildContext( + DriverConfigLoader configLoader, ProgrammaticArguments programmaticArguments) { + if (userContactPoint == null && !configContactPointProvided) { + return new DefaultDriverContext(configLoader, programmaticArguments) { + @Override + protected MetadataManager buildMetadataManager() { + return new MetadataManager(this) { + @Override + public boolean wasImplicitContactPoint() { + return true; + } + }; + } + }; + } + return super.buildContext(configLoader, programmaticArguments); + } + + /** Stops {@code adapterToStop} and logs any cleanup failure without masking the root error. */ + @VisibleForTesting + static void stopAdapterQuietly(Adapter adapterToStop) { + if (adapterToStop == null) { + return; + } + try { + adapterToStop.stop(); + } catch (IOException | RuntimeException e) { + LOG.warn("Failed to stop Adapter after CQL session build failure: {}", e.getMessage(), e); + } + } + private void checkAdapterSettings() throws UnknownHostException { checkAndSetupHost(); checkDatabaseUri(); @@ -283,64 +344,38 @@ void checkContactPoints() throws UnknownHostException { registeredAdapterEndPoint = null; } - List configContactPoints = null; - try (DriverConfigLoader defaultLoader = configLoader == null ? defaultConfigLoader() : null) { - DriverConfigLoader effectiveLoader = configLoader != null ? configLoader : defaultLoader; - if (effectiveLoader != null - && effectiveLoader - .getInitialConfig() - .getDefaultProfile() - .isDefined(DefaultDriverOption.CONTACT_POINTS)) { - configContactPoints = - effectiveLoader - .getInitialConfig() - .getDefaultProfile() - .getStringList(DefaultDriverOption.CONTACT_POINTS); - } - } - + List configContactPoints = loadConfigContactPoints(); int configCount = configContactPoints != null ? configContactPoints.size() : 0; - if (programmaticContactPoints.size() + configCount > 1) { + if (programmaticContactPoints.size() > 1 || configCount > 1) { throw new IllegalArgumentException( "At most one contact point can be provided when using SpannerCqlSessionBuilder, as it" + " connects to the local adapter."); } if (configCount == 1) { - HostAndPort parsed = HostAndPort.fromString(configContactPoints.get(0)); - if (!parsed.hasPort() || parsed.getPort() <= 0 || Strings.isNullOrEmpty(parsed.getHost())) { - throw new IllegalArgumentException( - "Contact point in DriverConfigLoader must specify host and a non-zero port, but got: " - + configContactPoints.get(0)); - } - final InetAddress[] resolvedAddresses; - try { - resolvedAddresses = InetAddress.getAllByName(parsed.getHost()); - } catch (UnknownHostException e) { - throw new IllegalArgumentException( - "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" - + " address, but could not resolve: " - + configContactPoints.get(0), - e); - } - for (InetAddress addr : resolvedAddresses) { - if (addr == null || !addr.isLoopbackAddress()) { + String configContactPoint = configContactPoints.get(0); + HostAndPort parsed = parseConfigContactPoint(configContactPoint); + InetAddress configAddress = + resolveAndValidateSingleLoopbackAddress(parsed.getHost(), configContactPoint); + + if (programmaticContactPoints.size() == 1) { + EndPoint providedEndPoint = programmaticContactPoints.iterator().next(); + InetSocketAddress programmaticAddress = validateAndExtractLoopbackAddress(providedEndPoint); + if (programmaticAddress.getPort() != parsed.getPort() + || !configAddress.equals(programmaticAddress.getAddress())) { throw new IllegalArgumentException( - "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" - + " address, but got: " - + addr); + "At most one contact point can be provided when using SpannerCqlSessionBuilder, as" + + " it connects to the local adapter."); } + iNetAddress = programmaticAddress.getAddress(); + port = programmaticAddress.getPort(); + userContactPoint = providedEndPoint; + configContactPointProvided = true; + LOG.debug("Using matching programmatic and config contact point: {}", programmaticAddress); + return; } - if (resolvedAddresses.length != 1) { - throw new IllegalArgumentException( - "At most one contact point address can be provided when using" - + " SpannerCqlSessionBuilder, but '" - + configContactPoints.get(0) - + "' resolved to " - + resolvedAddresses.length - + " addresses."); - } - iNetAddress = resolvedAddresses[0]; + + iNetAddress = configAddress; userContactPoint = null; configContactPointProvided = true; port = parsed.getPort(); @@ -357,30 +392,101 @@ void checkContactPoints() throws UnknownHostException { return; } - // Exactly one contact point was provided by the user. Validate it. + // Exactly one programmatic contact point was provided by the user. Validate it. EndPoint providedEndPoint = programmaticContactPoints.iterator().next(); - SocketAddress address = providedEndPoint.resolve(); - if (address == null) { - throw new IllegalArgumentException("Resolved contact point address cannot be null."); + InetSocketAddress inetSocketAddress = validateAndExtractLoopbackAddress(providedEndPoint); + iNetAddress = inetSocketAddress.getAddress(); + userContactPoint = providedEndPoint; + port = inetSocketAddress.getPort(); + LOG.debug("Using user-provided localhost contact point: {}", inetSocketAddress); + } + + private List loadConfigContactPoints() { + ClassLoader classLoader = programmaticArgumentsBuilder.build().getClassLoader(); + try (DriverConfigLoader defaultLoader = + configLoader == null ? defaultConfigLoader(classLoader) : null) { + DriverConfigLoader effectiveLoader = configLoader != null ? configLoader : defaultLoader; + if (effectiveLoader != null + && effectiveLoader + .getInitialConfig() + .getDefaultProfile() + .isDefined(DefaultDriverOption.CONTACT_POINTS)) { + return effectiveLoader + .getInitialConfig() + .getDefaultProfile() + .getStringList(DefaultDriverOption.CONTACT_POINTS); + } + return null; + } + } + + private static HostAndPort parseConfigContactPoint(String contactPoint) { + HostAndPort parsed = HostAndPort.fromString(contactPoint); + if (!parsed.hasPort() || parsed.getPort() <= 0 || Strings.isNullOrEmpty(parsed.getHost())) { + throw new IllegalArgumentException( + "Contact point in DriverConfigLoader must specify host and a non-zero port, but got: " + + contactPoint); } + return parsed; + } - if (address instanceof InetSocketAddress) { - InetSocketAddress inetSocketAddress = (InetSocketAddress) address; - iNetAddress = inetSocketAddress.getAddress(); - if (iNetAddress == null || !iNetAddress.isLoopbackAddress()) { + private static InetAddress resolveAndValidateSingleLoopbackAddress( + String host, String contactPoint) { + final InetAddress[] resolvedAddresses; + try { + resolvedAddresses = InetAddress.getAllByName(host); + } catch (UnknownHostException e) { + throw new IllegalArgumentException( + "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" + + " address, but could not resolve: " + + contactPoint, + e); + } + if (resolvedAddresses == null || resolvedAddresses.length == 0) { + throw new IllegalArgumentException( + "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" + + " address, but could not resolve: " + + contactPoint); + } + for (InetAddress address : resolvedAddresses) { + if (address == null || !address.isLoopbackAddress()) { throw new IllegalArgumentException( "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" + " address, but got: " - + inetSocketAddress); + + address); } - userContactPoint = providedEndPoint; - port = inetSocketAddress.getPort(); - LOG.debug("Using user-provided localhost contact point: {}", inetSocketAddress); - } else { + } + if (resolvedAddresses.length != 1) { + throw new IllegalArgumentException( + "At most one contact point address can be provided when using" + + " SpannerCqlSessionBuilder, but '" + + contactPoint + + "' resolved to " + + resolvedAddresses.length + + " addresses."); + } + return resolvedAddresses[0]; + } + + private static InetSocketAddress validateAndExtractLoopbackAddress(EndPoint providedEndPoint) { + SocketAddress address = providedEndPoint.resolve(); + if (address == null) { + throw new IllegalArgumentException("Resolved contact point address cannot be null."); + } + if (!(address instanceof InetSocketAddress)) { // Should not happen with typical Cassandra contact points. throw new IllegalArgumentException( "Unsupported contact point address type: " + address.getClass().getName()); } + InetSocketAddress inetSocketAddress = (InetSocketAddress) address; + InetAddress resolved = inetSocketAddress.getAddress(); + if (resolved == null || !resolved.isLoopbackAddress()) { + throw new IllegalArgumentException( + "Contact point for in-process SpannerCqlSessionBuilder must be a resolved loopback" + + " address, but got: " + + inetSocketAddress); + } + return inetSocketAddress; } private void checkNumGrpcChannels() { diff --git a/google-cloud-spanner-cassandra/src/test/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilderTest.java b/google-cloud-spanner-cassandra/src/test/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilderTest.java index f67c8efe..47fd13eb 100644 --- a/google-cloud-spanner-cassandra/src/test/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilderTest.java +++ b/google-cloud-spanner-cassandra/src/test/java/com/google/cloud/spanner/adapter/SpannerCqlSessionBuilderTest.java @@ -18,33 +18,75 @@ import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import com.datastax.oss.driver.api.core.config.DefaultDriverOption; import com.datastax.oss.driver.api.core.config.DriverConfigLoader; +import com.datastax.oss.driver.api.core.config.DriverExecutionProfile; +import com.datastax.oss.driver.api.core.context.DriverContext; +import com.datastax.oss.driver.api.core.loadbalancing.LoadBalancingPolicy; +import com.datastax.oss.driver.api.core.loadbalancing.NodeDistance; import com.datastax.oss.driver.api.core.metadata.EndPoint; +import com.datastax.oss.driver.api.core.metadata.Node; +import com.datastax.oss.driver.api.core.session.ProgrammaticArguments; +import com.datastax.oss.driver.internal.core.context.InternalDriverContext; +import com.datastax.oss.driver.internal.core.loadbalancing.DefaultLoadBalancingPolicy; +import com.datastax.oss.driver.internal.core.metadata.DefaultEndPoint; +import com.datastax.oss.driver.internal.core.metadata.DefaultNode; +import com.google.api.gax.grpc.GrpcTransportChannel; +import com.google.api.gax.rpc.FixedTransportChannelProvider; import com.google.auth.oauth2.GoogleCredentials; import com.google.cloud.spanner.adapter.SpannerCqlSessionBuilder.InstanceType; import com.google.spanner.adapter.v1.AdapterClient; import com.google.spanner.adapter.v1.AdapterSettings; +import com.google.spanner.adapter.v1.CreateSessionRequest; import com.google.spanner.adapter.v1.Session; import com.typesafe.config.ConfigFactory; +import io.grpc.ManagedChannel; +import io.grpc.MethodDescriptor; +import io.grpc.Server; +import io.grpc.ServerServiceDefinition; +import io.grpc.inprocess.InProcessChannelBuilder; +import io.grpc.inprocess.InProcessServerBuilder; +import io.grpc.protobuf.ProtoUtils; +import io.grpc.stub.ServerCalls; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.Field; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.ServerSocket; +import java.net.Socket; import java.net.SocketAddress; +import java.net.URL; +import java.net.URLConnection; +import java.net.URLStreamHandler; +import java.net.UnknownHostException; +import java.nio.charset.StandardCharsets; +import java.time.Duration; import java.util.Arrays; import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.UUID; import java.util.concurrent.CompletionStage; import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -281,6 +323,8 @@ public void testConfigLoaderContactPoint_validLoopbackAccepted() throws Exceptio assertEquals(9042, builder.getAdapterPort()); } + // Verifies that config contact points resolving to multiple addresses (including dual-stack + // IPv4/IPv6 loopback or mixed non-loopback) are rejected to enforce a 1-to-1 binding. @Test public void testConfigLoaderContactPoint_multipleResolvedAddressesThrowsIllegalArgumentException() throws Exception { @@ -522,4 +566,532 @@ public String asMetricPrefix() { } } } + + // Verifies that when no contact point is provided, the builder marks the contact point as + // implicit so DefaultLoadBalancingPolicy infers the local datacenter from the server. + @Test + public void testBuildContext_treatsDefaultContactPointAsImplicitWhenNoContactPointProvided() + throws Exception { + DriverConfigLoader configLoader = DriverConfigLoader.programmaticBuilder().build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader); + + builder.checkContactPoints(); + InternalDriverContext context = + (InternalDriverContext) + builder.buildContext(configLoader, ProgrammaticArguments.builder().build()); + try { + assertTrue(context.getMetadataManager().wasImplicitContactPoint()); + DefaultNode contactPointNode = registerSingleContactPoint(context, "datacenter1"); + Map nodes = Collections.singletonMap(UUID.randomUUID(), contactPointNode); + Map recordedDistances = new HashMap<>(); + + LoadBalancingPolicy policy = + new DefaultLoadBalancingPolicy(context, DriverExecutionProfile.DEFAULT_NAME); + policy.init(nodes, recordedDistances::put); + + assertEquals(NodeDistance.LOCAL, recordedDistances.get(contactPointNode)); + } finally { + closeDriverContext(context); + } + } + + // Verifies that explicit local datacenter settings (both programmatic and config-supplied) + // are preserved untouched without injecting or overriding driver config options. + @Test + public void testBuildContext_preservesProgrammaticAndConfigLocalDatacenter() throws Exception { + DriverConfigLoader defaultLoader = DriverConfigLoader.programmaticBuilder().build(); + SpannerCqlSessionBuilder programmaticBuilder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(defaultLoader) + .withLocalDatacenter("custom-dc"); + programmaticBuilder.checkContactPoints(); + InternalDriverContext programmaticContext = + (InternalDriverContext) + programmaticBuilder.buildContext( + defaultLoader, + ProgrammaticArguments.builder() + .withLocalDatacenter(DriverExecutionProfile.DEFAULT_NAME, "custom-dc") + .build()); + try { + assertEquals( + "custom-dc", programmaticContext.getLocalDatacenter(DriverExecutionProfile.DEFAULT_NAME)); + assertFalse( + programmaticContext + .getConfig() + .getDefaultProfile() + .isDefined(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)); + } finally { + closeDriverContext(programmaticContext); + } + + DriverConfigLoader configDcLoader = + DriverConfigLoader.programmaticBuilder() + .withString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER, "config-dc") + .build(); + SpannerCqlSessionBuilder configBuilder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configDcLoader); + configBuilder.checkContactPoints(); + DriverContext configContext = + configBuilder.buildContext(configDcLoader, ProgrammaticArguments.builder().build()); + try { + assertEquals( + "config-dc", + configContext + .getConfig() + .getDefaultProfile() + .getString(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)); + } finally { + closeDriverContext((InternalDriverContext) configContext); + } + } + + // Verifies that an explicit programmatic contact point is NOT marked implicit, preserving the + // standard driver requirement that an explicit local datacenter must also be supplied. + @Test + public void testBuildContext_doesNotMarkContactPointImplicitWhenExplicitContactPointProvided() + throws Exception { + DriverConfigLoader configLoader = DriverConfigLoader.programmaticBuilder().build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader) + .addContactPoint(new InetSocketAddress("127.0.0.1", 9042)); + + builder.checkContactPoints(); + InternalDriverContext context = + (InternalDriverContext) + builder.buildContext(configLoader, ProgrammaticArguments.builder().build()); + try { + assertFalse(context.getMetadataManager().wasImplicitContactPoint()); + assertFalse( + context + .getConfig() + .getDefaultProfile() + .isDefined(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)); + + DefaultNode contactPointNode = registerSingleContactPoint(context, "datacenter1"); + Map nodes = Collections.singletonMap(UUID.randomUUID(), contactPointNode); + LoadBalancingPolicy policy = + new DefaultLoadBalancingPolicy(context, DriverExecutionProfile.DEFAULT_NAME); + assertThrows(IllegalStateException.class, () -> policy.init(nodes, (node, distance) -> {})); + } finally { + closeDriverContext(context); + } + } + + // Verifies that specifying different ports in DriverConfigLoader and addContactPoint(...) is + // rejected because the in-process builder only connects to a single local adapter. + @Test + public void testContactPoints_mismatchedProgrammaticAndConfigContactPointsThrows() { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, Collections.singletonList("127.0.0.1:9042")) + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader) + .addContactPoint(new InetSocketAddress("127.0.0.1", 9043)); + + assertThrows(IllegalArgumentException.class, builder::checkContactPoints); + } + + // Verifies that named execution profiles without an explicit local datacenter still infer the + // server's datacenter when no contact point was supplied (a case that breaks if a fallback + // OptionsMap only defines the "default" profile). + @Test + public void testBuildContext_namedProfileInheritsLocalDatacenterWhenNoContactPointProvided() + throws Exception { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .startProfile("oltp") + .withDuration(DefaultDriverOption.REQUEST_TIMEOUT, Duration.ofSeconds(10)) + .endProfile() + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader); + + builder.checkContactPoints(); + InternalDriverContext context = + (InternalDriverContext) + builder.buildContext(configLoader, ProgrammaticArguments.builder().build()); + try { + DefaultNode contactPointNode = registerSingleContactPoint(context, "us-central1"); + Map nodes = Collections.singletonMap(UUID.randomUUID(), contactPointNode); + Map recordedDistances = new HashMap<>(); + + DefaultLoadBalancingPolicy policy = new DefaultLoadBalancingPolicy(context, "oltp"); + policy.init(nodes, recordedDistances::put); + + assertEquals(NodeDistance.LOCAL, recordedDistances.get(contactPointNode)); + } finally { + closeDriverContext(context); + } + } + + // Verifies that the caller's DriverConfigLoader is neither wrapped nor mutated (preserving + // supportsReloading() and config option visibility) and that non-default server datacenters + // are inferred rather than rejected against a hardcoded value. + @Test + public void testBuildContext_infersNonDefaultDatacenterFromContactPointAndPreservesConfigLoader() + throws Exception { + DriverConfigLoader configLoader = DriverConfigLoader.fromString(""); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader); + + builder.checkContactPoints(); + InternalDriverContext context = + (InternalDriverContext) + builder.buildContext(configLoader, ProgrammaticArguments.builder().build()); + try { + assertSame(configLoader, context.getConfigLoader()); + assertFalse(context.getConfigLoader().supportsReloading()); + assertFalse( + context + .getConfig() + .getDefaultProfile() + .isDefined(DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER)); + + DefaultNode contactPointNode = registerSingleContactPoint(context, "us-central1"); + Map nodes = Collections.singletonMap(UUID.randomUUID(), contactPointNode); + Map recordedDistances = new HashMap<>(); + + LoadBalancingPolicy policy = + new DefaultLoadBalancingPolicy(context, DriverExecutionProfile.DEFAULT_NAME); + policy.init(nodes, recordedDistances::put); + + assertEquals(NodeDistance.LOCAL, recordedDistances.get(contactPointNode)); + } finally { + closeDriverContext(context); + } + } + + // Verifies that specifying the same loopback address and port in both DriverConfigLoader and + // addContactPoint(...) is deduplicated and accepted instead of failing as multiple endpoints. + @Test + public void testContactPoints_matchingProgrammaticAndConfigContactPointAllowed() + throws Exception { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, Collections.singletonList("127.0.0.1:9042")) + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader) + .addContactPoint(new InetSocketAddress("127.0.0.1", 9042)); + + builder.checkContactPoints(); + + assertEquals(InetAddress.getByName("127.0.0.1"), builder.getAdapterInetAddress()); + assertEquals(9042, builder.getAdapterPort()); + } + + // Verifies that when no explicit DriverConfigLoader is set, checkContactPoints() loads default + // configuration using the ClassLoader passed to withClassLoader(...) so contact points defined + // in that ClassLoader's application.conf are honored. + @Test + public void testCheckContactPoints_respectsCustomClassLoader() throws Exception { + String hocon = "datastax-java-driver.basic.contact-points = [\"127.0.0.1:9042\"]\n"; + URL resourceUrl = + new URL( + "memory", + "", + 0, + "/application.conf", + new URLStreamHandler() { + @Override + protected URLConnection openConnection(URL url) { + return new URLConnection(url) { + @Override + public void connect() {} + + @Override + public InputStream getInputStream() { + return new ByteArrayInputStream(hocon.getBytes(StandardCharsets.UTF_8)); + } + }; + } + }); + ClassLoader customClassLoader = + new ClassLoader(SpannerCqlSessionBuilderTest.class.getClassLoader()) { + @Override + public URL getResource(String name) { + if ("application.conf".equals(name)) { + return resourceUrl; + } + return super.getResource(name); + } + + @Override + public Enumeration getResources(String name) throws IOException { + if ("application.conf".equals(name)) { + return Collections.enumeration(Collections.singletonList(resourceUrl)); + } + return super.getResources(name); + } + }; + + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withClassLoader(customClassLoader); + + builder.checkContactPoints(); + + assertEquals(InetAddress.getByName("127.0.0.1"), builder.getAdapterInetAddress()); + assertEquals(9042, builder.getAdapterPort()); + assertNull(builder.getUserContactPoint()); + } + + // Verifies that if super.buildAsync() fails after createAndStartAdapter() binds its socket, + // buildAsync() stops the started Adapter so its ServerSocket and resources do not leak. + @Test + public void testBuildAsync_stopsAdapterWhenSessionBuildFails() throws Exception { + String serverName = InProcessServerBuilder.generateName(); + MethodDescriptor createSessionMethod = + MethodDescriptor.newBuilder() + .setType(MethodDescriptor.MethodType.UNARY) + .setFullMethodName("google.spanner.adapter.v1.Adapter/CreateSession") + .setRequestMarshaller(ProtoUtils.marshaller(CreateSessionRequest.getDefaultInstance())) + .setResponseMarshaller(ProtoUtils.marshaller(Session.getDefaultInstance())) + .build(); + Server inProcessServer = null; + ManagedChannel inProcessChannel = null; + SpannerCqlSessionBuilder builder = null; + try { + inProcessServer = + InProcessServerBuilder.forName(serverName) + .directExecutor() + .addService( + ServerServiceDefinition.builder("google.spanner.adapter.v1.Adapter") + .addMethod( + createSessionMethod, + ServerCalls.asyncUnaryCall( + (request, responseObserver) -> { + responseObserver.onNext( + Session.newBuilder() + .setName(TEST_DATABASE_URI + "/sessions/test") + .build()); + responseObserver.onCompleted(); + })) + .build()) + .build() + .start(); + inProcessChannel = InProcessChannelBuilder.forName(serverName).directExecutor().build(); + + DriverConfigLoader failingConfigLoader = + DriverConfigLoader.programmaticBuilder() + .withString( + DefaultDriverOption.RETRY_POLICY_CLASS, "com.example.NonExistentRetryPolicy") + .build(); + + builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .setUsePlainText(true) + .setChannelProvider( + FixedTransportChannelProvider.create( + GrpcTransportChannel.create(inProcessChannel))) + .withConfigLoader(failingConfigLoader); + + CompletionStage stage = builder.buildAsync(); + assertThrows(ExecutionException.class, () -> stage.toCompletableFuture().get()); + + Adapter startedAdapter = builder.getAdapter(); + assertNotNull(startedAdapter); + int boundPort = startedAdapter.getBoundPort(); + assertTrue(boundPort > 0); + + assertThrows( + IOException.class, + () -> { + try (Socket probe = new Socket()) { + probe.connect( + new InetSocketAddress(InetAddress.getLoopbackAddress(), boundPort), 1000); + } + }); + } finally { + if (builder != null && builder.getAdapter() != null) { + try { + builder.getAdapter().stop(); + } catch (IOException | RuntimeException ignored) { + // Already stopped by buildAsync failure cleanup or never started. + } + } + if (inProcessChannel != null) { + inProcessChannel.shutdownNow(); + } + if (inProcessServer != null) { + inProcessServer.shutdownNow(); + } + } + } + + // Verifies that an explicit contact point supplied solely via DriverConfigLoader is not marked + // implicit in MetadataManager. + @Test + public void testBuildContext_configContactPointOnlyDoesNotMarkImplicit() throws Exception { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, Collections.singletonList("127.0.0.1:9042")) + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader); + + builder.checkContactPoints(); + InternalDriverContext context = + (InternalDriverContext) + builder.buildContext(configLoader, ProgrammaticArguments.builder().build()); + try { + assertFalse(context.getMetadataManager().wasImplicitContactPoint()); + } finally { + closeDriverContext(context); + } + } + + // Verifies that adding multiple programmatic contact points is rejected. + @Test + public void testProgrammaticContactPoints_multipleThrowsIllegalArgumentException() { + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .addContactPoint(new InetSocketAddress("127.0.0.1", 9042)) + .addContactPoint(new InetSocketAddress("127.0.0.1", 9043)); + + assertThrows(IllegalArgumentException.class, builder::checkContactPoints); + } + + // Verifies that matching ports on different loopback families (IPv6 ::1 vs IPv4 127.0.0.1) are + // treated as distinct contact points and rejected. + @Test + public void testContactPoints_matchingPortDifferentLoopbackAddressThrows() { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, Collections.singletonList("127.0.0.1:9042")) + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader) + .addContactPoint(new InetSocketAddress("::1", 9042)); + + assertThrows(IllegalArgumentException.class, builder::checkContactPoints); + } + + // Verifies that malformed config contact points (missing port or empty host) and unresolvable or + // empty DNS results are rejected with IllegalArgumentException. + @Test + public void testConfigLoaderContactPoint_invalidSyntaxOrResolutionThrows() throws Exception { + for (String invalidContactPoint : Arrays.asList("127.0.0.1", ":9042")) { + DriverConfigLoader configLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, + Collections.singletonList(invalidContactPoint)) + .build(); + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(configLoader); + assertThrows(IllegalArgumentException.class, builder::checkContactPoints); + } + + DriverConfigLoader unresolvableLoader = + DriverConfigLoader.programmaticBuilder() + .withStringList( + DefaultDriverOption.CONTACT_POINTS, Collections.singletonList("missing-host:9042")) + .build(); + SpannerCqlSessionBuilder unresolvableBuilder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .withConfigLoader(unresolvableLoader); + + try (MockedStatic mockedInetAddress = mockStatic(InetAddress.class)) { + mockedInetAddress + .when(() -> InetAddress.getAllByName("missing-host")) + .thenThrow(new UnknownHostException("missing-host")); + assertThrows(IllegalArgumentException.class, unresolvableBuilder::checkContactPoints); + + mockedInetAddress + .when(() -> InetAddress.getAllByName("missing-host")) + .thenReturn(new InetAddress[0]); + assertThrows(IllegalArgumentException.class, unresolvableBuilder::checkContactPoints); + } + } + + // Verifies that a programmatic EndPoint resolving to a non-InetSocketAddress is rejected. + @Test + public void testProgrammaticContactPoint_unsupportedSocketAddressThrows() { + SocketAddress customSocketAddress = new SocketAddress() {}; + EndPoint customEndPoint = + new EndPoint() { + @Override + public SocketAddress resolve() { + return customSocketAddress; + } + + @Override + public String asMetricPrefix() { + return "custom"; + } + }; + SpannerCqlSessionBuilder builder = + new SpannerCqlSessionBuilder() + .setDatabaseUri(TEST_DATABASE_URI) + .addContactEndPoint(customEndPoint); + + assertThrows(IllegalArgumentException.class, builder::checkContactPoints); + } + + // Verifies that stopAdapterQuietly safely handles null and swallows IOException/RuntimeException + // from Adapter.stop() so cleanup failures do not mask the underlying session build error. + @Test + public void testStopAdapterQuietly_handlesNullAndStopFailure() throws Exception { + SpannerCqlSessionBuilder.stopAdapterQuietly(null); + + Adapter failingIoAdapter = mock(Adapter.class); + doThrow(new IOException("close failure")).when(failingIoAdapter).stop(); + SpannerCqlSessionBuilder.stopAdapterQuietly(failingIoAdapter); + verify(failingIoAdapter).stop(); + + Adapter failingRuntimeAdapter = mock(Adapter.class); + doThrow(new IllegalStateException("not started")).when(failingRuntimeAdapter).stop(); + SpannerCqlSessionBuilder.stopAdapterQuietly(failingRuntimeAdapter); + verify(failingRuntimeAdapter).stop(); + } + + private static DefaultNode registerSingleContactPoint( + InternalDriverContext context, String datacenter) throws Exception { + EndPoint endPoint = + new DefaultEndPoint(new InetSocketAddress(InetAddress.getLoopbackAddress(), 9042)); + context.getMetadataManager().addContactPoints(Collections.singleton(endPoint)); + DefaultNode contactPointNode = + context.getMetadataManager().getContactPoints().iterator().next(); + Field datacenterField = DefaultNode.class.getDeclaredField("datacenter"); + datacenterField.setAccessible(true); + datacenterField.set(contactPointNode, datacenter); + return contactPointNode; + } + + private static void closeDriverContext(InternalDriverContext context) throws Exception { + context.getMetadataManager().forceCloseAsync().toCompletableFuture().get(5, TimeUnit.SECONDS); + context.getNettyOptions().onClose().get(5, TimeUnit.SECONDS); + } }