Refactor Liquibase integration to support environment-aware property pass-through

Signed-off-by: Dylan Miska <djmiska25@gmail.com>

Author: dmiska25

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/DataSourceClosingSpringLiquibase.java

@@ -23,17 +23,17 @@
 import liquibase.exception.LiquibaseException;
 import liquibase.integration.spring.SpringLiquibase;
 
-import org.springframework.beans.factory.DisposableBean;
 import org.springframework.util.ReflectionUtils;
 
 /**
  * A custom {@link SpringLiquibase} extension that closes the underlying
  * {@link DataSource} once the database has been migrated.
  *
  * @author Andy Wilkinson
+ * @author Dylan Miska
  * @since 4.0.0
  */
-public class DataSourceClosingSpringLiquibase extends SpringLiquibase implements DisposableBean {
+public class DataSourceClosingSpringLiquibase extends EnvironmentAwareSpringLiquibase {
 
 	private volatile boolean closeDataSourceOnceMigrated = true;
 
@@ -58,7 +58,8 @@ private void closeDataSource() {
 	}
 
 	@Override
-	public void destroy() throws Exception {
+	public void destroy() {
+		super.destroy();
 		if (!this.closeDataSourceOnceMigrated) {
 			closeDataSource();
 		}

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/EnvironmentAwareSpringLiquibase.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2012-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.liquibase.autoconfigure;
+
+import liquibase.Scope;
+import liquibase.exception.LiquibaseException;
+import liquibase.integration.spring.SpringLiquibase;
+import org.jspecify.annotations.Nullable;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A {@link SpringLiquibase} subclass that creates a Liquibase child scope with a
+ * reference to the Spring Environment, allowing the
+ * {@link EnvironmentConfigurationValueProvider} to access the correct Environment for
+ * configuration values.
+ *
+ * @author Dylan Miska
+ */
+class EnvironmentAwareSpringLiquibase extends SpringLiquibase implements ApplicationContextAware, DisposableBean {
+
+	private @Nullable String environmentId;
+
+	@Override
+	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+		this.environmentId = applicationContext.getId();
+	}
+
+	@Override
+	public void afterPropertiesSet() throws LiquibaseException {
+		try {
+			Map<String, Object> scopeValues = new HashMap<>();
+			scopeValues.put(EnvironmentConfigurationValueProvider.SPRING_ENV_ID_KEY, this.environmentId);
+			Scope.child(scopeValues, EnvironmentAwareSpringLiquibase.super::afterPropertiesSet);
+		}
+		catch (Exception ex) {
+			if (ex instanceof LiquibaseException) {
+				throw (LiquibaseException) ex;
+			}
+			throw new LiquibaseException(ex);
+		}
+	}
+
+	@Override
+	public void destroy() {
+		if (this.environmentId != null) {
+			EnvironmentConfigurationValueProvider.unregisterEnvironment(this.environmentId);
+		}
+	}
+
+}

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/EnvironmentConfigurationValueProvider.java

@@ -20,7 +20,9 @@
 import liquibase.configuration.ProvidedValue;
 import org.jspecify.annotations.Nullable;
 import org.springframework.core.env.Environment;
-import org.springframework.util.Assert;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * A Liquibase {@code ConfigurationValueProvider} that passes through properties defined
@@ -38,16 +40,23 @@
  * No relaxed binding or key transformation is performed. Keys are looked up exactly as
  * provided by Liquibase (including dots and casing), prefixed with
  * {@code spring.liquibase.properties.}.
+ *
+ * @author Dylan Miska
  */
-final class EnvironmentConfigurationValueProvider extends AbstractConfigurationValueProvider {
+public final class EnvironmentConfigurationValueProvider extends AbstractConfigurationValueProvider {
 
 	private static final String PREFIX = "spring.liquibase.properties.";
 
-	private final Environment environment;
+	public static final String SPRING_ENV_ID_KEY = "spring.environment.id";
 
-	EnvironmentConfigurationValueProvider(Environment environment) {
-		Assert.notNull(environment, "Environment must not be null");
-		this.environment = environment;
+	private static final Map<String, Environment> environments = new ConcurrentHashMap<>();
+
+	static void registerEnvironment(String environmentId, Environment environment) {
+		environments.put(environmentId, environment);
+	}
+
+	static void unregisterEnvironment(String environmentId) {
+		environments.remove(environmentId);
 	}
 
 	@Override
@@ -60,15 +69,25 @@ public int getPrecedence() {
 		if (keyAndAliases == null) {
 			return null;
 		}
+
+		String environmentId = liquibase.Scope.getCurrentScope().get(SPRING_ENV_ID_KEY, String.class);
+		if (environmentId == null) {
+			return null;
+		}
+
+		Environment environment = environments.get(environmentId);
+		if (environment == null) {
+			return null;
+		}
+
 		for (String requestedKey : keyAndAliases) {
-			if (requestedKey == null) {
-				continue;
-			}
-			String propertyName = PREFIX + requestedKey;
-			String value = this.environment.getProperty(propertyName);
-			if (value != null) {
-				return new ProvidedValue(requestedKey, requestedKey, value,
-						"Spring Environment property '" + propertyName + "'", this);
+			if (requestedKey != null) {
+				String propertyName = PREFIX + requestedKey;
+				String value = environment.getProperty(propertyName);
+				if (value != null) {
+					return new ProvidedValue(requestedKey, requestedKey, value,
+							"Spring Environment property '" + propertyName + "'", this);
+				}
 			}
 		}
 		return null;

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/LiquibaseAutoConfiguration.java

@@ -16,10 +16,11 @@
 
 package org.springframework.boot.liquibase.autoconfigure;
 
+import java.util.Objects;
+
 import javax.sql.DataSource;
 
 import liquibase.Liquibase;
-import liquibase.Scope;
 import liquibase.UpdateSummaryEnum;
 import liquibase.UpdateSummaryOutputEnum;
 import liquibase.change.DatabaseChange;
@@ -46,12 +47,12 @@
 import org.springframework.boot.liquibase.autoconfigure.LiquibaseAutoConfiguration.LiquibaseAutoConfigurationRuntimeHints;
 import org.springframework.boot.liquibase.autoconfigure.LiquibaseAutoConfiguration.LiquibaseDataSourceCondition;
 import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.context.annotation.ImportRuntimeHints;
-import org.springframework.core.env.Environment;
 import org.springframework.jdbc.core.ConnectionCallback;
 import org.springframework.jdbc.datasource.SimpleDriverDataSource;
 import org.springframework.util.Assert;
@@ -73,6 +74,7 @@
  * @author Evgeniy Cheban
  * @author Moritz Halbritter
  * @author Ahmed Ashour
+ * @author Dylan Miska
  * @since 4.0.0
  */
 @AutoConfiguration(after = DataSourceAutoConfiguration.class)
@@ -104,8 +106,8 @@ PropertiesLiquibaseConnectionDetails liquibaseConnectionDetails(LiquibasePropert
 		SpringLiquibase liquibase(ObjectProvider<DataSource> dataSource,
 				@LiquibaseDataSource ObjectProvider<DataSource> liquibaseDataSource, LiquibaseProperties properties,
 				ObjectProvider<SpringLiquibaseCustomizer> customizers, LiquibaseConnectionDetails connectionDetails,
-				Environment environment) {
-			registerLiquibaseConfigurationValueProvider(environment);
+				ApplicationContext applicationContext) {
+			registerLiquibaseConfigurationValueProvider(applicationContext);
 			SpringLiquibase liquibase = createSpringLiquibase(liquibaseDataSource.getIfAvailable(),
 					dataSource.getIfUnique(), connectionDetails);
 			liquibase.setChangeLog(properties.getChangeLog());
@@ -151,24 +153,26 @@ private SpringLiquibase createSpringLiquibase(@Nullable DataSource liquibaseData
 				@Nullable DataSource dataSource, LiquibaseConnectionDetails connectionDetails) {
 			DataSource migrationDataSource = getMigrationDataSource(liquibaseDataSource, dataSource, connectionDetails);
 			SpringLiquibase liquibase = (migrationDataSource == liquibaseDataSource
-					|| migrationDataSource == dataSource) ? new SpringLiquibase()
+					|| migrationDataSource == dataSource) ? new EnvironmentAwareSpringLiquibase()
 							: new DataSourceClosingSpringLiquibase();
 			liquibase.setDataSource(migrationDataSource);
 			return liquibase;
 		}
 
-		private void registerLiquibaseConfigurationValueProvider(Environment environment) {
-			liquibase.configuration.LiquibaseConfiguration liquibaseConfiguration = Scope.getCurrentScope()
+		private void registerLiquibaseConfigurationValueProvider(ApplicationContext applicationContext) {
+			liquibase.configuration.LiquibaseConfiguration liquibaseConfiguration = liquibase.Scope.getCurrentScope()
 				.getSingleton(liquibase.configuration.LiquibaseConfiguration.class);
 
-			// Remove any previously registered instance of our provider class
-			liquibaseConfiguration.getProviders()
+			boolean providerExists = liquibaseConfiguration.getProviders()
 				.stream()
-				.filter((provider) -> provider.getClass() == EnvironmentConfigurationValueProvider.class)
-				.toList()
-				.forEach(liquibaseConfiguration::unregisterProvider);
+				.anyMatch((provider) -> provider.getClass() == EnvironmentConfigurationValueProvider.class);
+
+			if (!providerExists) {
+				liquibaseConfiguration.registerProvider(new EnvironmentConfigurationValueProvider());
+			}
 
-			liquibaseConfiguration.registerProvider(new EnvironmentConfigurationValueProvider(environment));
+			EnvironmentConfigurationValueProvider.registerEnvironment(
+					Objects.requireNonNull(applicationContext.getId()), applicationContext.getEnvironment());
 		}
 
 		private DataSource getMigrationDataSource(@Nullable DataSource liquibaseDataSource,

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/LiquibaseProperties.java

@@ -36,6 +36,7 @@
  * @author Eddú Meléndez
  * @author Ferenc Gratzer
  * @author Evgeniy Cheban
+ * @author Dylan Miska
  * @since 4.0.0
  */
 @ConfigurationProperties(prefix = "spring.liquibase", ignoreUnknownFields = false)

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/endpoint/LiquibaseEndpoint.java

@@ -20,10 +20,12 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
 import javax.sql.DataSource;
 
+import liquibase.Scope;
 import liquibase.changelog.ChangeSet.ExecType;
 import liquibase.changelog.RanChangeSet;
 import liquibase.changelog.StandardChangeLogHistoryService;
@@ -36,6 +38,7 @@
 import org.springframework.boot.actuate.endpoint.OperationResponseBody;
 import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
 import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
+import org.springframework.boot.liquibase.autoconfigure.EnvironmentConfigurationValueProvider;
 import org.springframework.context.ApplicationContext;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -45,6 +48,7 @@
  *
  * @author Eddú Meléndez
  * @author Nabil Fawwaz Elqayyim
+ * @author Dylan Miska
  * @since 4.0.0
  */
 @Endpoint(id = "liquibase")
@@ -58,18 +62,26 @@ public LiquibaseEndpoint(ApplicationContext context) {
 	}
 
 	@ReadOperation
-	public LiquibaseBeansDescriptor liquibaseBeans() {
+	public LiquibaseBeansDescriptor liquibaseBeans() throws Exception {
 		ApplicationContext target = this.context;
 		Map<@Nullable String, ContextLiquibaseBeansDescriptor> contextBeans = new HashMap<>();
 		while (target != null) {
-			Map<String, LiquibaseBeanDescriptor> liquibaseBeans = new HashMap<>();
-			DatabaseFactory factory = DatabaseFactory.getInstance();
-			target.getBeansOfType(SpringLiquibase.class)
-				.forEach((name, liquibase) -> liquibaseBeans.put(name, createReport(liquibase, factory)));
-			ApplicationContext parent = target.getParent();
-			contextBeans.put(target.getId(),
-					new ContextLiquibaseBeansDescriptor(liquibaseBeans, (parent != null) ? parent.getId() : null));
-			target = parent;
+			Map<String, Object> scopeValues = new HashMap<>();
+			scopeValues.put(EnvironmentConfigurationValueProvider.SPRING_ENV_ID_KEY,
+					Objects.requireNonNull(target.getId()));
+			ApplicationContext currentContext = target;
+			Scope.child(scopeValues, () -> {
+				Map<String, LiquibaseBeanDescriptor> liquibaseBeans = new HashMap<>();
+				DatabaseFactory factory = DatabaseFactory.getInstance();
+				currentContext.getBeansOfType(SpringLiquibase.class)
+					.forEach((name, liquibase) -> liquibaseBeans.put(name, createReport(liquibase, factory)));
+				ApplicationContext parent = currentContext.getParent();
+				contextBeans.put(currentContext.getId(),
+						new ContextLiquibaseBeansDescriptor(liquibaseBeans, (parent != null) ? parent.getId() : null));
+				return null;
+			});
+
+			target = target.getParent();
 		}
 		return new LiquibaseBeansDescriptor(contextBeans);
 	}

module/spring-boot-liquibase/src/test/java/org/springframework/boot/liquibase/actuate/endpoint/LiquibaseEndpointTests.java

@@ -53,6 +53,7 @@
  * @author Andy Wilkinson
  * @author Stephane Nicoll
  * @author Leo Li
+ * @author Dylan Miska
  */
 @WithResource(name = "db/changelog/db.changelog-master.yaml", content = """
 		databaseChangeLog:
@@ -176,6 +177,26 @@ void whenMultipleLiquibaseBeansArePresentChangeSetsAreCorrectlyReportedForEachBe
 			});
 	}
 
+	@Test
+	@WithResource(name = "db/create-custom-schema.sql", content = "CREATE SCHEMA \"CustomSchema\";")
+	void customLiquibasePropertyIsAppliedDuringEndpointCall() {
+		this.contextRunner.withUserConfiguration(Config.class, DataSourceWithSchemaConfiguration.class)
+			.withPropertyValues("spring.liquibase.default-schema=CustomSchema",
+					"spring.liquibase.properties.liquibase.preserveSchemaCase=true")
+			.run((context) -> {
+				Map<String, LiquibaseBeanDescriptor> liquibaseBeans = context.getBean(LiquibaseEndpoint.class)
+					.liquibaseBeans()
+					.getContexts()
+					.get(context.getId())
+					.getLiquibaseBeans();
+				// If preserveSchemaCase wasn't applied, Liquibase would fail to find the
+				// mixed-case schema
+				assertThat(liquibaseBeans.get("liquibase").getChangeSets()).hasSize(1);
+				assertThat(liquibaseBeans.get("liquibase").getChangeSets().get(0).getChangeLog())
+					.isEqualTo("db/changelog/db.changelog-master.yaml");
+			});
+	}
+
 	private boolean getAutoCommit(DataSource dataSource) throws SQLException {
 		try (Connection connection = dataSource.getConnection()) {
 			return connection.getAutoCommit();