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()); + } }