From 8ff03f7e1778e5681dc4292947d6f0062e93afa0 Mon Sep 17 00:00:00 2001 From: Sakthivel Subramanian <179120858+sakthivelmanii@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:55:55 +0000 Subject: [PATCH] fix(spanner): recompute default host on toBuilder().setUniverseDomain() Calling toBuilder().setUniverseDomain(...) on a built SpannerOptions instance previously retained the materialized default host (https://spanner.googleapis.com) because Builder(SpannerOptions) copied options.getHost() and ServiceOptions.Builder(ServiceOptions) copied the resolved host. Track only the explicitly configured host in SpannerOptions and restore that value in Builder(SpannerOptions), allowing default hosts to be recomputed via getDefaultHost() when the universe domain changes while preserving explicit custom hosts, emulator hosts, and Omni hosts. --- .../google/cloud/spanner/SpannerOptions.java | 22 ++- .../cloud/spanner/SpannerOptionsTest.java | 138 ++++++++++++++++++ 2 files changed, 156 insertions(+), 4 deletions(-) diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index b33065b65c84..b6df6bb6286e 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -339,6 +339,7 @@ static GcpChannelPoolOptions mergeWithDefaultChannelPoolOptions( private final CallContextConfigurator callContextConfigurator; private final CloseableExecutorProvider asyncExecutorProvider; private final String compressorName; + private final String configuredHost; private final String emulatorHost; private final boolean leaderAwareRoutingEnabled; private final boolean enableDirectAccess; @@ -1049,6 +1050,7 @@ protected SpannerOptions(Builder builder) { callContextConfigurator = builder.callContextConfigurator; asyncExecutorProvider = builder.asyncExecutorProvider; compressorName = builder.compressorName; + configuredHost = builder.host; emulatorHost = builder.emulatorHost; leaderAwareRoutingEnabled = builder.leaderAwareRoutingEnabled; enableDirectAccess = builder.enableDirectAccess; @@ -1538,7 +1540,18 @@ protected Builder() { Builder(SpannerOptions options) { super(options); - this.host = options.getHost(); + // Restore only an explicitly configured host (not a materialized default host), so + // subsequent setUniverseDomain() calls recompute the default host via getDefaultHost(). + // Fallback preserves a custom host on options deserialized from older versions where + // configuredHost was not present. + this.host = + options.configuredHost != null + ? options.configuredHost + : (options.emulatorHost == null + && !Objects.equals(options.getHost(), options.getDefaultHost()) + ? options.getHost() + : null); + super.setHost(this.host); this.emulatorHost = options.emulatorHost; this.numChannels = options.numChannels; this.transportChannelExecutorThreadNameFormat = @@ -2595,18 +2608,19 @@ public Builder setAutoTaggingTracerLimit(int autoTaggingTracerLimit) { @SuppressWarnings("rawtypes") @Override public SpannerOptions build() { - // Set the host of emulator has been set. + // Set the host if emulator has been set. if (emulatorHost != null && this.instanceType != InstanceType.OMNI) { if (!emulatorHost.startsWith("http")) { emulatorHost = "http://" + emulatorHost; } - this.host = emulatorHost; - super.setHost(this.host); + super.setHost(emulatorHost); // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid // needing certificates. this.setChannelConfigurator(ManagedChannelBuilder::usePlaintext); // As we are using plain text, we should never send any credentials. this.setCredentials(NoCredentials.getInstance()); + } else { + super.setHost(this.host); } if (this.numChannels == null) { this.numChannels = diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index 9f346cc50d2b..587f87c94fae 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -1870,4 +1870,142 @@ public void testToBuilderPreservesInstanceTypeAndUsePlainText() throws Exception assertEquals(SpannerOptions.InstanceType.OMNI, fromBuilder.getInstanceType()); assertTrue(fromBuilder.isUsePlainText()); } + + @Test + public void testToBuilderSetUniverseDomainUpdatesDefaultHost() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setEmulatorHost(null) + .build(); + assertEquals("https://spanner.googleapis.com", base.getHost()); + assertEquals("spanner.googleapis.com:443", base.getEndpoint()); + + SpannerOptions rebuilt = base.toBuilder().setUniverseDomain("universe.example").build(); + assertEquals("universe.example", rebuilt.getUniverseDomain()); + assertEquals("https://spanner.universe.example", rebuilt.getHost()); + assertEquals("spanner.universe.example:443", rebuilt.getEndpoint()); + assertEquals("universe.example", rebuilt.getSpannerStubSettings().getUniverseDomain()); + assertEquals("spanner.universe.example:443", rebuilt.getSpannerStubSettings().getEndpoint()); + assertEquals("universe.example", rebuilt.getInstanceAdminStubSettings().getUniverseDomain()); + assertEquals( + "spanner.universe.example:443", rebuilt.getInstanceAdminStubSettings().getEndpoint()); + assertEquals("universe.example", rebuilt.getDatabaseAdminStubSettings().getUniverseDomain()); + assertEquals( + "spanner.universe.example:443", rebuilt.getDatabaseAdminStubSettings().getEndpoint()); + } + + @Test + public void testToBuilderChangeUniverseDomainUpdatesDefaultHost() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setEmulatorHost(null) + .setUniverseDomain("domain1.example") + .build(); + assertEquals("https://spanner.domain1.example", base.getHost()); + assertEquals("spanner.domain1.example:443", base.getEndpoint()); + + SpannerOptions rebuilt = base.toBuilder().setUniverseDomain("domain2.example").build(); + assertEquals("domain2.example", rebuilt.getUniverseDomain()); + assertEquals("https://spanner.domain2.example", rebuilt.getHost()); + assertEquals("spanner.domain2.example:443", rebuilt.getEndpoint()); + assertEquals("spanner.domain2.example:443", rebuilt.getSpannerStubSettings().getEndpoint()); + } + + @Test + public void testToBuilderSetUniverseDomainPreservesCustomHost() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setHost("https://custom.spanner.example:1234") + .build(); + + SpannerOptions rebuilt = base.toBuilder().setUniverseDomain("universe.example").build(); + assertEquals("universe.example", rebuilt.getUniverseDomain()); + assertEquals("https://custom.spanner.example:1234", rebuilt.getHost()); + assertEquals("custom.spanner.example:1234", rebuilt.getEndpoint()); + } + + @Test + public void testToBuilderSetUniverseDomainPreservesExplicitDefaultHost() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setHost("https://spanner.googleapis.com") + .build(); + + SpannerOptions rebuilt = base.toBuilder().setUniverseDomain("universe.example").build(); + assertEquals("universe.example", rebuilt.getUniverseDomain()); + assertEquals("https://spanner.googleapis.com", rebuilt.getHost()); + assertEquals("spanner.googleapis.com:443", rebuilt.getEndpoint()); + } + + @Test + public void testToBuilderSetHostAndUniverseDomainOrderIndependent() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setEmulatorHost(null) + .build(); + + SpannerOptions hostThenUniverse = + base.toBuilder() + .setHost("https://custom.example:8443") + .setUniverseDomain("universe.example") + .build(); + SpannerOptions universeThenHost = + base.toBuilder() + .setUniverseDomain("universe.example") + .setHost("https://custom.example:8443") + .build(); + + assertEquals("https://custom.example:8443", hostThenUniverse.getHost()); + assertEquals("universe.example", hostThenUniverse.getUniverseDomain()); + assertEquals("https://custom.example:8443", universeThenHost.getHost()); + assertEquals("universe.example", universeThenHost.getUniverseDomain()); + } + + @Test + public void testToBuilderSetHostNullResetsToUniverseDomainDefaultHost() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setCredentials(NoCredentials.getInstance()) + .setHost("https://custom.example:1234") + .build(); + + SpannerOptions rebuilt = + base.toBuilder().setHost(null).setUniverseDomain("universe.example").build(); + assertEquals("universe.example", rebuilt.getUniverseDomain()); + assertEquals("https://spanner.universe.example", rebuilt.getHost()); + assertEquals("spanner.universe.example:443", rebuilt.getEndpoint()); + } + + @Test + public void testToBuilderClearEmulatorHostAndSetUniverseDomain() { + SpannerOptions base = + SpannerOptions.newBuilder() + .setProjectId("test-project") + .setEmulatorHost("localhost:9010") + .build(); + assertEquals("http://localhost:9010", base.getHost()); + assertTrue(base.isEmulatorEnabled()); + + SpannerOptions rebuiltEmulator = base.toBuilder().build(); + assertEquals("http://localhost:9010", rebuiltEmulator.getHost()); + assertTrue(rebuiltEmulator.isEmulatorEnabled()); + + SpannerOptions rebuiltNonEmulator = + base.toBuilder().setEmulatorHost(null).setUniverseDomain("universe.example").build(); + assertEquals("universe.example", rebuiltNonEmulator.getUniverseDomain()); + assertEquals("https://spanner.universe.example", rebuiltNonEmulator.getHost()); + assertEquals("spanner.universe.example:443", rebuiltNonEmulator.getEndpoint()); + assertFalse(rebuiltNonEmulator.isEmulatorEnabled()); + } }