getCommands() {
+ return commands;
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DataFlowSchemaMigrationException.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DataFlowSchemaMigrationException.java
new file mode 100644
index 0000000000..c59f339de4
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DataFlowSchemaMigrationException.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.flyway;
+
+/**
+ * Exception is thrown when an error occurs while migrating the dataflow schema.
+ *
+ * @author Glenn Renfro
+ */
+public class DataFlowSchemaMigrationException extends RuntimeException{
+
+ private static final long serialVersionUID = 2000527476523962349L;
+
+ /**
+ * Exception will use the message specified.
+ *
+ * @param message the text that will be associated with the exception.
+ * @param throwable the exception that is being wrapped.
+ */
+ public DataFlowSchemaMigrationException(String message, Throwable throwable) {
+ super(message, throwable);
+ }
+
+ /**
+ * Exception will use the message specified.
+ * @param message the text that will be associated with the exception.
+ */
+ public DataFlowSchemaMigrationException(String message) {
+ super(message);
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DatabaseDriverUtils.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DatabaseDriverUtils.java
new file mode 100644
index 0000000000..cf5ab9a466
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/DatabaseDriverUtils.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2022-2022 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.cloud.dataflow.common.flyway;
+
+import java.sql.DatabaseMetaData;
+
+import javax.sql.DataSource;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.boot.jdbc.DatabaseDriver;
+import org.springframework.jdbc.support.JdbcUtils;
+import org.springframework.jdbc.support.MetaDataAccessException;
+
+/**
+ * Provides utility methods to help with {@link DatabaseDriver} related operations.
+ */
+public final class DatabaseDriverUtils {
+
+ private static final Logger LOG = LoggerFactory.getLogger(DatabaseDriverUtils.class);
+
+ private DatabaseDriverUtils() {
+ }
+
+ /**
+ * Finds a database driver suitable for a datasource.
+ * By default, the jdbc url reported from the database metdata is used to determine
+ * the driver. It also handles the special case where MariaDB reports a 'jdbc:maria'
+ * url eventhough the original url was prefixed with 'jdbc:mysql'.
+ *
+ * @param dataSource the datasource to inspect
+ * @return a database driver suitable for the datasource
+ */
+ public static DatabaseDriver getDatabaseDriver(DataSource dataSource) {
+ // copied from boot's flyway auto-config to get matching db vendor id (but adjusted
+ // to handle the case when MariaDB driver is being used against MySQL database).
+ try {
+ String url = JdbcUtils.extractDatabaseMetaData(dataSource, DatabaseMetaData::getURL);
+ DatabaseDriver databaseDriver = DatabaseDriver.fromJdbcUrl(url);
+ if (databaseDriver == DatabaseDriver.MARIADB) {
+ // MariaDB reports a 'jdbc:maria' url even when user specified 'jdbc:mysql'.
+ // Verify the underlying database is not really MySql.
+ String product = JdbcUtils.extractDatabaseMetaData(dataSource, DatabaseMetaData::getDatabaseProductName);
+ if (DatabaseDriver.MYSQL.name().equalsIgnoreCase(product)) {
+ LOG.info("Using MariaDB driver against MySQL database - will use MySQL");
+ databaseDriver = DatabaseDriver.MYSQL;
+ }
+ }
+ return databaseDriver;
+ }
+ catch (MetaDataAccessException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializer.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializer.java
new file mode 100644
index 0000000000..aa98aec176
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializer.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2022-2023 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.cloud.dataflow.common.flyway;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.boot.env.EnvironmentPostProcessor;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.core.Ordered;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.MapPropertySource;
+
+/**
+ * An {@link ApplicationContextInitializer} that replaces any configured 'spring.flyways.locations'
+ * properties that contain the '{vendor}' token with 'mysql' when using the MariaDB driver
+ * to access a MySQL database.
+ *
+ *
Typically property manipulation like this is implemented as an {@link EnvironmentPostProcessor} but
+ * in order to work with applications that are using Config server it must be a context initializer
+ * so it can run after the {@code org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration}
+ * context initializer.
+ *
+ * @author Chris Bono
+ */
+public class FlywayVendorReplacingApplicationContextInitializer implements
+ ApplicationContextInitializer, Ordered {
+
+ private final Logger log = LoggerFactory.getLogger(FlywayVendorReplacingApplicationContextInitializer.class);
+
+ @Override
+ public void initialize(ConfigurableApplicationContext applicationContext) {
+
+ ConfigurableEnvironment env = applicationContext.getEnvironment();
+
+ // If there is a spring.datasource.url prefixed w/ "jdbc:mysql:" and using the MariaDB driver then replace {vendor}
+ boolean usingMariaDriver = env.getProperty("spring.datasource.driver-class-name", "").equals("org.mariadb.jdbc.Driver");
+ boolean usingMySqlUrl = env.getProperty("spring.datasource.url", "").startsWith("jdbc:mysql:");
+ if (!(usingMariaDriver && usingMySqlUrl)) {
+ return;
+ }
+
+ log.info("Using MariaDB driver w/ MySQL url - looking for '{vendor}' in 'spring.flyway.locations'");
+
+ // Look for spring.flyway.locations[0..N] and if found then override it w/ vendor replaced version
+ Map replacedLocations = new HashMap<>();
+
+ int prodIdx = 0;
+ while (true) {
+ String locationPropName = String.format("spring.flyway.locations[%d]", prodIdx++);
+ String configuredLocation = env.getProperty(locationPropName);
+ if (configuredLocation == null) {
+ break;
+ }
+ if (configuredLocation.contains("{vendor}")) {
+ String replaceLocation = configuredLocation.replace("{vendor}", "mysql");
+ replacedLocations.put(locationPropName, replaceLocation);
+ }
+ }
+
+ if (replacedLocations.isEmpty()) {
+ log.info("No properties with '{vendor}' found to replace");
+ return;
+ }
+
+ log.info("Replacing '{vendor}' in {}", replacedLocations);
+
+ env.getPropertySources().addFirst(new MapPropertySource("overrideVendorInFlywayLocations", replacedLocations));
+ }
+
+ /**
+ * The precedence for execution order - should execute last.
+ *
+ * @return lowest precedence to ensure it executes after other initializers
+ */
+ @Override
+ public int getOrder() {
+ return Ordered.LOWEST_PRECEDENCE;
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommand.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommand.java
new file mode 100644
index 0000000000..9e5b94b9aa
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommand.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.flyway;
+
+import java.sql.Connection;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Class keeping a sql command and its possible suppressing sql codes together.
+ *
+ * @author Janne Valkealahti
+ *
+ */
+public class SqlCommand {
+
+ private final String command;
+ private final List suppressedErrorCodes;
+
+ /**
+ * Convenience method returning new instance.
+ *
+ * @param command the command
+ * @return the sql command
+ */
+ public static SqlCommand from(String command) {
+ return new SqlCommand(command, null);
+ }
+
+ /**
+ * Convenience method returning new instance.
+ *
+ * @param command the command
+ * @param suppressedErrorCode the suppressed error code
+ * @return the sql command
+ */
+ public static SqlCommand from(String command, int suppressedErrorCode) {
+ return new SqlCommand(command, suppressedErrorCode);
+ }
+
+ public SqlCommand() {
+ this(null, null);
+ }
+
+ /**
+ * Instantiates a new sql command.
+ *
+ * @param command the command
+ * @param suppressedErrorCode the suppressed error code
+ */
+ public SqlCommand(String command, int suppressedErrorCode) {
+ this(command, Collections.singletonList(suppressedErrorCode));
+ }
+
+ /**
+ * Instantiates a new sql command.
+ *
+ * @param command the command
+ * @param suppressedErrorCodes the suppressed error codes
+ */
+ public SqlCommand(String command, List suppressedErrorCodes) {
+ this.command = command;
+ this.suppressedErrorCodes = suppressedErrorCodes;
+ }
+
+ /**
+ * Gets the command.
+ *
+ * @return the command
+ */
+ public String getCommand() {
+ return command;
+ }
+
+ /**
+ * Gets the suppressed error codes.
+ *
+ * @return the suppressed error codes
+ */
+ public List getSuppressedErrorCodes() {
+ return suppressedErrorCodes;
+ }
+
+ /**
+ * Checks if this command can handle execution directly
+ * in a given jdbc template.
+ *
+ * @return true, if command can handle jdbc template
+ */
+ public boolean canHandleInJdbcTemplate() {
+ return false;
+ }
+
+ /**
+ * Handle command in a given jdbc template.
+ *
+ * @param jdbcTemplate the jdbc template
+ * @param connection the sql connection
+ */
+ public void handle(JdbcTemplate jdbcTemplate, Connection connection) {
+ // expected to get handled in a sub-class
+ throw new UnsupportedOperationException("Not supported in a base class");
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommandsRunner.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommandsRunner.java
new file mode 100644
index 0000000000..7e1e42989d
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SqlCommandsRunner.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.flyway;
+
+import java.sql.Connection;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.SingleConnectionDataSource;
+import org.springframework.jdbc.support.SQLExceptionTranslator;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * Simple utility class to run commands with a connection and possibly suppress
+ * errors.
+ *
+ * @author Janne Valkealahti
+ *
+ */
+public class SqlCommandsRunner {
+
+ private static final Logger logger = LoggerFactory.getLogger(SqlCommandsRunner.class);
+
+ /**
+ * Execute list of {@code SqlCommand} by suppressing errors if those are given
+ * with a command.
+ *
+ * @param connection the connection
+ * @param commands the sql commands
+ */
+ public void execute(Connection connection, List commands) {
+ JdbcTemplate jdbcTemplate = new JdbcTemplate(new SingleConnectionDataSource(connection, true));
+ SQLExceptionTranslator origExceptionTranslator = jdbcTemplate.getExceptionTranslator();
+
+ for (SqlCommand command : commands) {
+ if (command.canHandleInJdbcTemplate()) {
+ command.handle(jdbcTemplate, connection);
+ }
+ else {
+ if(!ObjectUtils.isEmpty(command.getSuppressedErrorCodes())) {
+ jdbcTemplate.setExceptionTranslator(new SuppressSQLErrorCodesTranslator(command.getSuppressedErrorCodes()));
+ }
+ try {
+ logger.debug("Executing command {}", command.getCommand());
+ jdbcTemplate.execute(command.getCommand());
+ } catch (SuppressDataAccessException e) {
+ logger.debug("Suppressing error {}", e);
+ }
+ // restore original translator in case next command
+ // doesn't define suppressing codes.
+ jdbcTemplate.setExceptionTranslator(origExceptionTranslator);
+ }
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressDataAccessException.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressDataAccessException.java
new file mode 100644
index 0000000000..28098afbc7
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressDataAccessException.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.flyway;
+
+import org.springframework.dao.DataAccessException;
+
+/**
+ * Special type of {@link DataAccessException} indicating that error can be
+ * suppressed.
+ *
+ * @author Janne Valkealahti
+ *
+ */
+@SuppressWarnings("serial")
+public class SuppressDataAccessException extends DataAccessException {
+
+ /**
+ * Instantiates a new suppress data access exception.
+ *
+ * @param msg the msg
+ * @param cause the cause
+ */
+ public SuppressDataAccessException(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressSQLErrorCodesTranslator.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressSQLErrorCodesTranslator.java
new file mode 100644
index 0000000000..385daa4905
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/java/org/springframework/cloud/dataflow/common/flyway/SuppressSQLErrorCodesTranslator.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.flyway;
+
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.slf4j.LoggerFactory;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator;
+import org.springframework.util.Assert;
+
+/**
+ * {@link SQLErrorCodeSQLExceptionTranslator} suppressing errors based on
+ * configured list of codes by throwing dedicated {@link SuppressDataAccessException}.
+ *
+ * @author Janne Valkealahti
+ *
+ */
+public class SuppressSQLErrorCodesTranslator extends SQLErrorCodeSQLExceptionTranslator {
+
+ private static final org.slf4j.Logger logger = LoggerFactory.getLogger(SuppressSQLErrorCodesTranslator.class);
+ private final List errorCodes;
+
+ /**
+ * Instantiates a new suppress SQL error codes translator.
+ *
+ * @param errorCode the error code
+ */
+ public SuppressSQLErrorCodesTranslator(int errorCode) {
+ this(Arrays.asList(errorCode));
+ }
+
+ /**
+ * Instantiates a new suppress SQL error codes translator.
+ *
+ * @param errorCodes the error codes
+ */
+ public SuppressSQLErrorCodesTranslator(List errorCodes) {
+ super();
+ Assert.notNull(errorCodes, "errorCodes must be set");
+ this.errorCodes = errorCodes;
+ }
+
+ @Override
+ protected DataAccessException customTranslate(String task, String sql, SQLException sqlEx) {
+ logger.debug("Checking sql error code {} against {}", sqlEx.getErrorCode(), errorCodes);
+ if (errorCodes.contains(sqlEx.getErrorCode())) {
+ return new SuppressDataAccessException(task, sqlEx);
+ }
+ return super.customTranslate(task, sql, sqlEx);
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/META-INF/services/org.flywaydb.core.extensibility.Plugin b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/META-INF/services/org.flywaydb.core.extensibility.Plugin
new file mode 100644
index 0000000000..ccab893acc
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/META-INF/services/org.flywaydb.core.extensibility.Plugin
@@ -0,0 +1,2 @@
+org.flywaydb.database.mysql.mariadb.MariaDB57DatabaseType
+org.flywaydb.database.mysql.MySQL57DatabaseType
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/org/flywaydb/database/version.txt b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/org/flywaydb/database/version.txt
new file mode 100644
index 0000000000..a4a0d40d19
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/main/resources/org/flywaydb/database/version.txt
@@ -0,0 +1 @@
+@flyway.version@
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/test/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializerTests.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/test/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializerTests.java
new file mode 100644
index 0000000000..6270f5ff7a
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-flyway/src/test/java/org/springframework/cloud/dataflow/common/flyway/FlywayVendorReplacingApplicationContextInitializerTests.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2022-2023 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.cloud.dataflow.common.flyway;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+/**
+ * Tests for {@link FlywayVendorReplacingApplicationContextInitializer}.
+ */
+class FlywayVendorReplacingApplicationContextInitializerTests {
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("vendorReplacedProperlyProvider")
+ void vendorReplacedProperly(boolean usingMySqlUrl, boolean usingMariaDriver, List configuredLocationProps, List finalLocationProps) {
+ List props = new ArrayList<>();
+ props.add("spring.datasource.url=" + (usingMySqlUrl ? "jdbc:mysql://localhost:3306/dataflow?permitMysqlScheme" : "jdbc:mariadb://localhost:3306/dataflow"));
+ props.add("spring.datasource.driver-class-name=" + (usingMariaDriver ? "org.mariadb.jdbc.Driver" : "org.mysql.jdbc.Driver"));
+ props.addAll(configuredLocationProps);
+
+ // Prime an actual env by running it through the AppContextRunner with the configured properties
+ new ApplicationContextRunner().withPropertyValues(props.toArray(new String[0])).run((context) -> {
+ ConfigurableEnvironment env = context.getEnvironment();
+
+ // Sanity check the locations props are as expected
+ configuredLocationProps.forEach((location) -> {
+ String key = location.split("=")[0];
+ String value = location.split("=")[1];
+ assertThat(env.getProperty(key)).isEqualTo(value);
+ });
+
+ // Run the env through the ACI
+ FlywayVendorReplacingApplicationContextInitializer flywayVendorReplacingInitializer = new FlywayVendorReplacingApplicationContextInitializer();
+ flywayVendorReplacingInitializer.initialize(context);
+
+ // Verify they are replaced as expected
+ finalLocationProps.forEach((location) -> {
+ String key = location.split("=")[0];
+ String value = location.split("=")[1];
+ assertThat(env.getProperty(key)).isEqualTo(value);
+ });
+ });
+ }
+
+ private static Stream vendorReplacedProperlyProvider() {
+ return Stream.of(
+ arguments(Named.of("singleLocationWithVendor",true), true,
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}"),
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/mysql")
+ ),
+ arguments(Named.of("singleLocationWithoutVendor",true), true,
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/foo"),
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/foo")
+ ),
+ arguments(Named.of("noLocations",true), true,
+ Collections.emptyList(),
+ Collections.emptyList()
+ ),
+ arguments(Named.of("multiLocationsAllWithVendor",true), true,
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/{vendor}",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/{vendor}",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/{vendor}"),
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/mysql",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/mysql",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/mysql")
+ ),
+ arguments(Named.of("multiLocationsSomeWithVendor",true), true,
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/{vendor}",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/foo",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/{vendor}"),
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/mysql",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/foo",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/mysql")
+ ),
+ arguments(Named.of("multiLocationsNoneWithVendor",true), true,
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/foo",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/bar",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/zaa"),
+ Arrays.asList(
+ "spring.flyway.locations[0]=classpath:org/skipper/db0/foo",
+ "spring.flyway.locations[1]=classpath:org/skipper/db1/bar",
+ "spring.flyway.locations[2]=classpath:org/skipper/db2/zaa")
+ ),
+ arguments(Named.of("mariaUrlWithMariaDriverDoesNotReplace",false), true,
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}"),
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}")
+ ),
+ arguments(Named.of("mysqlUrlWithMysqlDriverDoesNotReplace",true), false,
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}"),
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}")
+ ),
+ arguments(Named.of("mariaUrlMysqlDriverDoesNotReplace",false), false,
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}"),
+ Collections.singletonList("spring.flyway.locations[0]=classpath:org/skipper/db/{vendor}")
+ )
+ );
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/pom.xml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/pom.xml
new file mode 100644
index 0000000000..6edc2eb238
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/pom.xml
@@ -0,0 +1,70 @@
+
+
+ 4.0.0
+
+ spring-cloud-dataflow-parent
+ org.springframework.cloud
+ 3.0.0-SNAPSHOT
+ ../../spring-cloud-dataflow-parent
+
+ spring-cloud-dataflow-common-persistence
+ spring-cloud-dataflow-audit
+ Spring Cloud Data Flow Common Persistence Utilities
+ jar
+
+ true
+ 3.4.1
+
+
+
+ org.hibernate.orm
+ hibernate-core
+
+
+ org.springframework.data
+ spring-data-jpa
+
+
+ org.springframework.boot
+ spring-boot-starter-jdbc
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-javadoc-plugin
+ ${maven-javadoc-plugin.version}
+
+
+ javadoc
+
+ jar
+
+ package
+
+
+
+
+ org.apache.maven.plugins
+ maven-source-plugin
+ 3.3.0
+
+
+ source
+
+ jar
+
+ package
+
+
+
+
+
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobType.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobType.java
new file mode 100644
index 0000000000..a50350b076
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobType.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.persistence.type;
+
+import org.hibernate.type.AbstractSingleColumnStandardBasicType;
+import org.hibernate.type.descriptor.java.StringJavaType;
+import org.hibernate.type.descriptor.jdbc.AdjustableJdbcType;
+import org.hibernate.type.descriptor.jdbc.ClobJdbcType;
+import org.hibernate.type.descriptor.jdbc.VarcharJdbcType;
+
+import org.springframework.util.Assert;
+
+/**
+ * Provide for Hibernate and Postgres incompatibility for columns of type text.
+ * @author Corneil du Plessis
+ */
+public class DatabaseAwareLobType extends AbstractSingleColumnStandardBasicType {
+
+ public static final DatabaseAwareLobType INSTANCE = new DatabaseAwareLobType();
+
+
+
+ public DatabaseAwareLobType() {
+ super( getDbDescriptor(), StringJavaType.INSTANCE );
+ }
+
+ public static AdjustableJdbcType getDbDescriptor() {
+ if( isPostgres() ) {
+ return VarcharJdbcType.INSTANCE;
+ }
+ else {
+ return ClobJdbcType.DEFAULT;
+ }
+ }
+
+ /**
+ * This method will be used to set an indicator that the database driver in use is PostgreSQL.
+ * if postgresDB true if PostgreSQL.
+ */
+ private static boolean isPostgres() {
+ Boolean postgresDatabase = DatabaseTypeAwareInitializer.getPostgresDatabase();
+ Assert.notNull(postgresDatabase, "Expected postgresDatabase to be set");
+ return postgresDatabase;
+ }
+
+ @Override
+ public String getName() {
+ return "database_aware_lob";
+ }
+}
\ No newline at end of file
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobUserType.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobUserType.java
new file mode 100644
index 0000000000..0b29fda148
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseAwareLobUserType.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2024 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.cloud.dataflow.common.persistence.type;
+
+import java.util.function.BiConsumer;
+
+import org.hibernate.type.descriptor.java.BasicJavaType;
+import org.hibernate.type.descriptor.java.StringJavaType;
+import org.hibernate.type.descriptor.jdbc.AdjustableJdbcType;
+import org.hibernate.type.descriptor.jdbc.ClobJdbcType;
+import org.hibernate.type.descriptor.jdbc.JdbcType;
+import org.hibernate.type.descriptor.jdbc.VarcharJdbcType;
+import org.hibernate.usertype.BaseUserTypeSupport;
+import org.hibernate.usertype.UserType;
+
+import org.springframework.util.Assert;
+
+/**
+ * A {@link UserType} that provides for Hibernate and Postgres incompatibility for columns of
+ * type text.
+ *
+ * @author Corneil du Plessis
+ * @author Chris Bono
+ * @since 3.0.0
+ */
+public class DatabaseAwareLobUserType extends BaseUserTypeSupport {
+
+ @Override
+ protected void resolve(BiConsumer, JdbcType> resolutionConsumer) {
+ resolutionConsumer.accept(StringJavaType.INSTANCE, getDbDescriptor());
+ }
+
+ public static AdjustableJdbcType getDbDescriptor() {
+ if( isPostgres() ) {
+ return VarcharJdbcType.INSTANCE;
+ }
+ else {
+ return ClobJdbcType.DEFAULT;
+ }
+ }
+
+ private static boolean isPostgres() {
+ Boolean postgresDatabase = DatabaseTypeAwareInitializer.getPostgresDatabase();
+ Assert.notNull(postgresDatabase, "Expected postgresDatabase to be set");
+ return postgresDatabase;
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseTypeAwareInitializer.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseTypeAwareInitializer.java
new file mode 100644
index 0000000000..c67454afe2
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/java/org/springframework/cloud/dataflow/common/persistence/type/DatabaseTypeAwareInitializer.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2019-2020 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.cloud.dataflow.common.persistence.type;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.core.Ordered;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+public class DatabaseTypeAwareInitializer implements ApplicationContextInitializer, Ordered {
+ private static final Logger logger = LoggerFactory.getLogger(DatabaseTypeAwareInitializer.class);
+ private static Boolean postgresDatabase = null;
+
+ public DatabaseTypeAwareInitializer() {
+ }
+
+ @Override
+ public void initialize(ConfigurableApplicationContext applicationContext) {
+ ConfigurableEnvironment env = applicationContext.getEnvironment();
+ String property = env.getProperty("spring.datasource.driver-class-name", "");
+ logger.info("checking database driver type:{}", property);
+ postgresDatabase = property.contains("postgres");
+ }
+
+ public static Boolean getPostgresDatabase() {
+ return postgresDatabase;
+ }
+
+ @Override
+ public int getOrder() {
+ return Ordered.HIGHEST_PRECEDENCE;
+ }
+
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/resources/META-INF/spring.factories b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000000..189a0a6f71
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/main/resources/META-INF/spring.factories
@@ -0,0 +1 @@
+org.springframework.context.ApplicationContextInitializer=org.springframework.cloud.dataflow.common.persistence.type.DatabaseTypeAwareInitializer
\ No newline at end of file
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/test/java/org/springframework/cloud/dataflow/common/persistence/DatabaseTypeAwareInitializerTest.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/test/java/org/springframework/cloud/dataflow/common/persistence/DatabaseTypeAwareInitializerTest.java
new file mode 100644
index 0000000000..1eec1f34a2
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-persistence/src/test/java/org/springframework/cloud/dataflow/common/persistence/DatabaseTypeAwareInitializerTest.java
@@ -0,0 +1,38 @@
+package org.springframework.cloud.dataflow.common.persistence;
+
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.cloud.dataflow.common.persistence.type.DatabaseTypeAwareInitializer;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DatabaseTypeAwareInitializerTest {
+ private static final Logger logger = LoggerFactory.getLogger(DatabaseTypeAwareInitializerTest.class);
+
+ @Test
+ void initPostgres() {
+ initDriverType("org.postgresql.Driver");
+ assertThat(DatabaseTypeAwareInitializer.getPostgresDatabase()).isNotNull();
+ assertThat(DatabaseTypeAwareInitializer.getPostgresDatabase()).isTrue();
+ }
+
+ @Test
+ void initMariaDB() {
+ initDriverType("org.mariadb.jdbc.Driver");
+ assertThat(DatabaseTypeAwareInitializer.getPostgresDatabase()).isNotNull();
+ assertThat(DatabaseTypeAwareInitializer.getPostgresDatabase()).isFalse();
+ }
+ private void initDriverType(String driverClassName) {
+ // Prime an actual env by running it through the AppContextRunner with the configured properties
+ new ApplicationContextRunner().withPropertyValues("spring.datasource.driver-class-name=" + driverClassName).run((context) -> {
+ ConfigurableEnvironment env = context.getEnvironment();
+ logger.info("spring.datasource.driver-class-name={}", env.getProperty("spring.datasource.driver-class-name"));
+ DatabaseTypeAwareInitializer initializer = new DatabaseTypeAwareInitializer();
+ initializer.initialize(context);
+ });
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/pom.xml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/pom.xml
new file mode 100644
index 0000000000..10185f900c
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/pom.xml
@@ -0,0 +1,36 @@
+
+
+ 4.0.0
+
+ spring-cloud-dataflow-common-test-docker-junit5
+ jar
+
+ Spring Cloud Dataflow Common Docker Test JUnit5 Support
+ Utilities to help using junit5
+
+
+ org.springframework.cloud
+ spring-cloud-dataflow-common-parent
+ 3.0.0-SNAPSHOT
+
+
+ true
+
+
+
+ org.springframework.cloud
+ spring-cloud-dataflow-common-test-docker
+ ${project.version}
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+
+
+
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose.java
new file mode 100644
index 0000000000..3c4be95dd4
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@Documented
+@Inherited
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Repeatable(DockerComposes.class)
+@ExtendWith(DockerComposeExtension.class)
+public @interface DockerCompose {
+
+ int order() default 0;
+ String id() default "";
+ boolean start() default true;
+ String[] locations() default {};
+ String[] services() default {};
+ String log() default "";
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeCluster.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeCluster.java
new file mode 100644
index 0000000000..81b635c156
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeCluster.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.DockerComposeRule;
+
+public interface DockerComposeCluster {
+
+ DockerComposeRule getRule();
+ void start();
+ void stop();
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeExtension.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeExtension.java
new file mode 100644
index 0000000000..e8b3d8c463
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeExtension.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ExtensionContext.Store;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.platform.commons.util.AnnotationUtils;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.DockerComposeRule;
+import org.springframework.cloud.dataflow.common.test.docker.junit5.DockerComposeManager.DockerComposeData;
+
+/**
+ * {@code JUnit5} extension handling docker compose integration.
+ *
+ * @author Janne Valkealahti
+ *
+ */
+public class DockerComposeExtension
+ implements BeforeAllCallback, BeforeEachCallback, AfterAllCallback, AfterEachCallback, ParameterResolver {
+
+ private static final Namespace NAMESPACE = Namespace.create(DockerComposeExtension.class);
+
+ @Override
+ public void beforeAll(ExtensionContext extensionContext) throws Exception {
+ // add class level compose info into compose manager
+ DockerComposeManager dockerComposeManager = getDockerComposeManager(extensionContext);
+
+ Class testClass = extensionContext.getRequiredTestClass();
+ String classKey = extensionContext.getRequiredTestClass().getSimpleName();
+
+ List dockerComposeAnnotations = AnnotationUtils.findRepeatableAnnotations(testClass, DockerCompose.class);
+ for (DockerCompose dockerComposeAnnotation : dockerComposeAnnotations) {
+ DockerComposeData dockerComposeData = new DockerComposeData(dockerComposeAnnotation.id(),
+ dockerComposeAnnotation.locations(), dockerComposeAnnotation.services(),
+ dockerComposeAnnotation.log(), dockerComposeAnnotation.start(), dockerComposeAnnotation.order());
+ dockerComposeManager.addClassDockerComposeData(classKey, dockerComposeData);
+ }
+ }
+
+ @Override
+ public void beforeEach(ExtensionContext context) throws Exception {
+ // add method level compose info into compose manager
+ DockerComposeManager dockerComposeManager = getDockerComposeManager(context);
+
+ Method testMethod = context.getRequiredTestMethod();
+ String classKey = context.getRequiredTestClass().getSimpleName();
+ String methodKey = context.getRequiredTestMethod().getName();
+
+ List dockerComposeAnnotations = AnnotationUtils.findRepeatableAnnotations(testMethod, DockerCompose.class);
+ for (DockerCompose dockerComposeAnnotation : dockerComposeAnnotations) {
+ DockerComposeData dockerComposeData = new DockerComposeData(dockerComposeAnnotation.id(),
+ dockerComposeAnnotation.locations(), dockerComposeAnnotation.services(),
+ dockerComposeAnnotation.log(), dockerComposeAnnotation.start(), dockerComposeAnnotation.order());
+ dockerComposeManager.addMethodDockerComposeData(classKey, methodKey, dockerComposeData);
+ }
+ dockerComposeManager.build(classKey, methodKey);
+ }
+
+ @Override
+ public void afterEach(ExtensionContext context) throws Exception {
+ // clean containers related to class and method
+ DockerComposeManager dockerComposeManager = getDockerComposeManager(context);
+ String classKey = context.getRequiredTestClass().getSimpleName();
+ String methodKey = context.getRequiredTestMethod().getName();
+ dockerComposeManager.stop(classKey, methodKey);
+ }
+
+ @Override
+ public void afterAll(ExtensionContext context) throws Exception {
+ }
+
+ @Override
+ public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
+ throws ParameterResolutionException {
+ return (parameterContext.getParameter().getType() == DockerComposeInfo.class);
+ }
+
+ @Override
+ public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
+ throws ParameterResolutionException {
+ DockerComposeManager dockerComposeManager = getDockerComposeManager(extensionContext);
+ return new DefaultDockerComposeInfo(dockerComposeManager);
+ }
+
+ private static DockerComposeManager getDockerComposeManager(ExtensionContext context) {
+ Class testClass = context.getRequiredTestClass();
+ Store store = getStore(context);
+ return store.getOrComputeIfAbsent(testClass, (key)->{return new DockerComposeManager();}, DockerComposeManager.class);
+ }
+
+ private static Store getStore(ExtensionContext context) {
+ return context.getRoot().getStore(NAMESPACE);
+ }
+
+ private static class DefaultDockerComposeInfo implements DockerComposeInfo {
+ private final DockerComposeManager dockerComposeManager;
+
+ public DefaultDockerComposeInfo(DockerComposeManager dockerComposeManager) {
+ this.dockerComposeManager = dockerComposeManager;
+ }
+
+ @Override
+ public DockerComposeCluster id(String id) {
+ return new DefaultDockerComposeCluster(dockerComposeManager, id);
+ }
+ }
+
+ private static class DefaultDockerComposeCluster implements DockerComposeCluster {
+
+ private final DockerComposeManager dockerComposeManager;
+ private final String id;
+
+ public DefaultDockerComposeCluster(DockerComposeManager dockerComposeManager, String id) {
+ this.dockerComposeManager = dockerComposeManager;
+ this.id = id;
+ }
+
+ @Override
+ public DockerComposeRule getRule() {
+ return dockerComposeManager.getRule(id);
+ }
+
+ @Override
+ public void start() {
+ dockerComposeManager.startId(id);
+ }
+
+ @Override
+ public void stop() {
+ dockerComposeManager.stopId(id);
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-completion/src/test/support/boot13/src/main/java/com/acme/boot13/Main.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeInfo.java
similarity index 74%
rename from spring-cloud-dataflow-completion/src/test/support/boot13/src/main/java/com/acme/boot13/Main.java
rename to spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeInfo.java
index 3c146901d9..4df416d24e 100644
--- a/spring-cloud-dataflow-completion/src/test/support/boot13/src/main/java/com/acme/boot13/Main.java
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeInfo.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016 the original author or authors.
+ * Copyright 2018-2019 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.
@@ -13,12 +13,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+package org.springframework.cloud.dataflow.common.test.docker.junit5;
-package com.acme.boot13;
+public interface DockerComposeInfo {
-public class Main {
-
- public static void main(String[] args) {
- System.out.println("Hello World");
- }
+ DockerComposeCluster id(String id);
}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeManager.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeManager.java
new file mode 100644
index 0000000000..1afc75d1e8
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposeManager.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.DockerComposeRule;
+import org.springframework.cloud.dataflow.common.test.docker.compose.DockerComposeRule.Builder;
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.DockerComposeFiles;
+
+import static org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.HealthChecks.toHaveAllPortsOpen;
+
+/**
+ *
+ * @author Janne Valkealahti
+ *
+ */
+public class DockerComposeManager {
+
+ private final Map rules = new HashMap<>();
+ private final Map> classKeys = new HashMap<>();
+ private final Map> methodKeys = new HashMap<>();
+
+ public DockerComposeManager() {}
+
+ public void addClassDockerComposeData(String classKey, DockerComposeData dockerComposeData) {
+ String key = dockerComposeData.id + "$" + classKey;
+ classKeys.putIfAbsent(key, new ArrayList<>());
+ classKeys.get(key).add(dockerComposeData);
+ }
+
+ public void addMethodDockerComposeData(String classKey, String methodKey, DockerComposeData dockerComposeData) {
+ String key = dockerComposeData.id + "$" + classKey;
+ if (classKeys.containsKey(key)) {
+ classKeys.get(key).add(dockerComposeData);
+ }
+ else {
+ key = dockerComposeData.id + "$" + classKey + methodKey;
+ methodKeys.putIfAbsent(key, new ArrayList<>());
+ methodKeys.get(key).add(dockerComposeData);
+ }
+ }
+
+ public DockerComposeRule getRule(String id) {
+ for (Entry e : rules.entrySet()) {
+ String idMatch = e.getKey().substring(0, e.getKey().indexOf("$"));
+ if (id.equals(idMatch)) {
+ return e.getValue();
+ }
+ }
+ throw new IllegalArgumentException("Id " + id + " not found");
+ }
+
+ public void build(String classKey, String methodKey) {
+
+ ArrayList toStart = new ArrayList<>();
+
+ // class level
+ for (Entry> e : classKeys.entrySet()) {
+ String key = e.getKey();
+ ArrayList locations = new ArrayList<>();
+ ArrayList services = new ArrayList<>();
+ boolean start = true;
+ Integer order = Integer.MAX_VALUE;
+ String log = "";
+ for (DockerComposeData dockerComposeData : e.getValue()) {
+ locations.addAll(Arrays.asList(dockerComposeData.getLocations()));
+ services.addAll(Arrays.asList(dockerComposeData.getServices()));
+ if (!dockerComposeData.isStart()) {
+ start = false;
+ }
+ if (dockerComposeData.getOrder() < order) {
+ order = dockerComposeData.getOrder();
+ }
+ if (dockerComposeData.getLog() != null && dockerComposeData.getLog().length() > 0) {
+ log = dockerComposeData.getLog();
+ }
+ }
+ Builder builder = DockerComposeRule.builder();
+ builder.files(DockerComposeFiles.from(locations.toArray(new String[0])));
+ for (String service : services) {
+ builder.waitingForService(service, toHaveAllPortsOpen(), DockerComposeRule.DEFAULT_TIMEOUT);
+ }
+ builder.saveLogsTo("build/test-docker-logs/" + log + classKey + "-" + methodKey);
+ DockerComposeRule rule = builder.build();
+ rules.put(key, rule);
+ if (start) {
+ toStart.add(new OrderingWrapper(order, rule));
+ }
+ }
+
+ // method level
+ for (Entry> e : methodKeys.entrySet()) {
+ String key = e.getKey();
+ ArrayList locations = new ArrayList<>();
+ ArrayList services = new ArrayList<>();
+ boolean start = true;
+ Integer order = Integer.MAX_VALUE;
+ String log = "";
+ for (DockerComposeData dockerComposeData : e.getValue()) {
+ locations.addAll(Arrays.asList(dockerComposeData.getLocations()));
+ services.addAll(Arrays.asList(dockerComposeData.getServices()));
+ if (!dockerComposeData.isStart()) {
+ start = false;
+ }
+ if (dockerComposeData.getOrder() < order) {
+ order = dockerComposeData.getOrder();
+ }
+ if (dockerComposeData.getLog() != null && dockerComposeData.getLog().length() > 0) {
+ log = dockerComposeData.getLog();
+ }
+ }
+ Builder builder = DockerComposeRule.builder();
+ builder.files(DockerComposeFiles.from(locations.toArray(new String[0])));
+ for (String service : services) {
+ builder.waitingForService(service, toHaveAllPortsOpen(), DockerComposeRule.DEFAULT_TIMEOUT);
+ }
+ builder.saveLogsTo("build/test-docker-logs/" + log + classKey + "-" + methodKey);
+ DockerComposeRule rule = builder.build();
+ rules.put(key, rule);
+ if (start) {
+ toStart.add(new OrderingWrapper(order, rule));
+ }
+ }
+
+ Collections.sort(toStart);
+ for (OrderingWrapper w : toStart) {
+ try {
+ w.getRule().before();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ }
+
+ public void stop(String classKey, String methodKey) {
+ ArrayList toRemove = new ArrayList<>();
+ for (Entry e : rules.entrySet()) {
+ String idMatch = e.getKey().substring(e.getKey().indexOf("$") + 1, e.getKey().length());
+ if (idMatch.equals(classKey)) {
+ toRemove.add(e.getKey());
+ }
+ if (idMatch.equals(classKey + methodKey)) {
+ toRemove.add(e.getKey());
+ }
+ }
+ for (String remove : toRemove) {
+ DockerComposeRule rule = rules.remove(remove);
+ if (rule != null) {
+ rule.after();
+ }
+ }
+ // for now, just clear both class and method keys
+ classKeys.clear();
+ methodKeys.clear();
+ }
+
+ public void startId(String id) {
+ DockerComposeRule rule = null;
+ for (Entry e : rules.entrySet()) {
+ String idMatch = e.getKey().substring(0, e.getKey().indexOf("$"));
+ if (id.equals(idMatch)) {
+ rule = e.getValue();
+ }
+ }
+ if (rule != null) {
+ try {
+ rule.before();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public void stopId(String id) {
+ DockerComposeRule rule = null;
+ for (Entry e : rules.entrySet()) {
+ String idMatch = e.getKey().substring(0, e.getKey().indexOf("$"));
+ if (id.equals(idMatch)) {
+ rule = e.getValue();
+ }
+ }
+ if (rule != null) {
+ rule.after();
+ }
+ }
+
+ public static class DockerComposeData {
+
+ private final String id;
+ private final boolean start;
+ private final String[] locations;
+ private final String[] services;
+ private final String log;
+ private final int order;
+
+ public DockerComposeData(String id, String[] locations, String[] services, String log, boolean start, int order) {
+ this.id = id;
+ this.locations = locations;
+ this.services = services;
+ this.log = log;
+ this.start = start;
+ this.order = order;
+ }
+
+ public String[] getLocations() {
+ return locations;
+ }
+
+ public String[] getServices() {
+ return services;
+ }
+
+ public String getLog() {
+ return log;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public boolean isStart() {
+ return start;
+ }
+
+ public int getOrder() {
+ return order;
+ }
+ }
+
+ private static class OrderingWrapper implements Comparable{
+ Integer order;
+ DockerComposeRule rule;
+
+ public OrderingWrapper(Integer order, DockerComposeRule rule) {
+ this.order = order;
+ this.rule = rule;
+ }
+
+ public Integer getOrder() {
+ return order;
+ }
+
+ public DockerComposeRule getRule() {
+ return rule;
+ }
+
+ @Override
+ public int compareTo(OrderingWrapper o) {
+ return getOrder().compareTo(o.getOrder());
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposes.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposes.java
new file mode 100644
index 0000000000..303eec75de
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerComposes.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Inherited
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface DockerComposes {
+
+ DockerCompose[] value();
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/LegacyDockerComposeExtension.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/LegacyDockerComposeExtension.java
new file mode 100644
index 0000000000..4b641ad6fc
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/java/org/springframework/cloud/dataflow/common/test/docker/junit5/LegacyDockerComposeExtension.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.util.List;
+
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.DockerComposeRule;
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.DockerComposeFiles;
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.ProjectName;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.DockerMachine;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.ClusterWait;
+import org.springframework.cloud.dataflow.common.test.docker.compose.logging.LogCollector;
+
+public class LegacyDockerComposeExtension extends DockerComposeRule implements BeforeAllCallback, AfterAllCallback {
+
+ private LegacyDockerComposeExtension(DockerComposeFiles files, List clusterWaits,
+ LogCollector logCollector, DockerMachine machine, boolean pullOnStartup, ProjectName projectName) {
+ super(files, clusterWaits, logCollector, machine, pullOnStartup, projectName);
+ }
+
+ @Override
+ public void afterAll(ExtensionContext context) throws Exception {
+ after();
+ }
+
+ @Override
+ public void beforeAll(ExtensionContext context) throws Exception {
+ before();
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static class Builder extends DockerComposeRule.Builder {
+
+ @Override
+ public LegacyDockerComposeExtension build() {
+ return new LegacyDockerComposeExtension(files, clusterWaits, logCollector, machine, pullOnStartup,
+ projectName);
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-shell-core/.jdk8 b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/resources/application.properties
similarity index 100%
rename from spring-cloud-dataflow-shell-core/.jdk8
rename to spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/main/resources/application.properties
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose1Tests.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose1Tests.java
new file mode 100644
index 0000000000..144dcaf0f5
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose1Tests.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerExecutionException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+
+@DockerCompose(locations = {"src/test/resources/docker-compose-1.yml"})
+class DockerCompose1Tests {
+
+ @Test
+ void compose(DockerComposeInfo dockerComposeInfo) throws IOException, InterruptedException {
+ assertThat(dockerComposeInfo).isNotNull();
+ assertThat(dockerComposeInfo.id("").getRule()).isNotNull();
+ assertThat(dockerComposeInfo.id("").getRule().containers().container("testservice1")).isNotNull();
+
+ Throwable thrown = catchThrowable(() -> {
+ dockerComposeInfo.id("").getRule().containers().container("testservice2").state();
+ });
+ assertThat(thrown)
+ .isInstanceOf(DockerExecutionException.class)
+ .hasNoCause();
+ assertThat(thrown).message()
+ .containsIgnoringCase("No such service: testservice2");
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose2Tests.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose2Tests.java
new file mode 100644
index 0000000000..fe0081fd15
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose2Tests.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@DockerCompose(id = DockerCompose2Tests.CLUSTER1, locations = {"src/test/resources/docker-compose-1.yml"})
+@DockerCompose(id = DockerCompose2Tests.CLUSTER2, locations = {"src/test/resources/docker-compose-2.yml"}, start = false)
+@ExtendWith(DockerComposeExtension.class)
+public class DockerCompose2Tests {
+
+ public final static String CLUSTER1 = "dc1";
+ public final static String CLUSTER2 = "dc2";
+ public final static String CLUSTER3 = "dc3";
+ public final static String CLUSTER4 = "dc4";
+
+ @Test
+ @DockerCompose(id = DockerCompose2Tests.CLUSTER3, locations = {"src/test/resources/docker-compose-3.yml"})
+ @DockerCompose(id = DockerCompose2Tests.CLUSTER4, locations = {"src/test/resources/docker-compose-4.yml"}, start = false)
+ void compose(DockerComposeInfo dockerComposeInfo) throws IOException, InterruptedException {
+
+ dockerComposeInfo.id(CLUSTER2).start();
+ Thread.sleep(1000);
+ dockerComposeInfo.id(CLUSTER4).start();
+ Thread.sleep(1000);
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose3Tests.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose3Tests.java
new file mode 100644
index 0000000000..a78fb664da
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/java/org/springframework/cloud/dataflow/common/test/docker/junit5/DockerCompose3Tests.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020 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.cloud.dataflow.common.test.docker.junit5;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerExecutionException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+
+@DockerCompose(locations = {"classpath:org/springframework/cloud/dataflow/common/test/docker/junit5/docker-compose-cp1.yml"})
+class DockerCompose3Tests {
+
+ @Test
+ void compose(DockerComposeInfo dockerComposeInfo) throws IOException, InterruptedException {
+ assertThat(dockerComposeInfo).isNotNull();
+ assertThat(dockerComposeInfo.id("").getRule()).isNotNull();
+ assertThat(dockerComposeInfo.id("").getRule().containers().container("testservice1")).isNotNull();
+
+ Throwable thrown = catchThrowable(() -> {
+ dockerComposeInfo.id("").getRule().containers().container("testservice2").state();
+ });
+ assertThat(thrown).isInstanceOf(DockerExecutionException.class).hasNoCause()
+ .message().containsIgnoringCase("No such service: testservice2");
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-1.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-1.yml
new file mode 100644
index 0000000000..cb8dbff2d9
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-1.yml
@@ -0,0 +1,4 @@
+services:
+ testservice1:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-2.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-2.yml
new file mode 100644
index 0000000000..4500793c1f
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-2.yml
@@ -0,0 +1,5 @@
+services:
+ testservice2:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-3.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-3.yml
new file mode 100644
index 0000000000..38da37eb91
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-3.yml
@@ -0,0 +1,5 @@
+services:
+ testservice3:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-4.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-4.yml
new file mode 100644
index 0000000000..1605ea0e78
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-4.yml
@@ -0,0 +1,4 @@
+services:
+ testservice4:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-5.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-5.yml
new file mode 100644
index 0000000000..c7e4357f6c
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-5.yml
@@ -0,0 +1,4 @@
+services:
+ testservice5:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-6.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-6.yml
new file mode 100644
index 0000000000..682a582af4
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/docker-compose-6.yml
@@ -0,0 +1,5 @@
+services:
+ testservice6:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/org/springframework/cloud/dataflow/common/test/docker/junit5/docker-compose-cp1.yml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/org/springframework/cloud/dataflow/common/test/docker/junit5/docker-compose-cp1.yml
new file mode 100644
index 0000000000..cb8dbff2d9
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker-junit5/src/test/resources/org/springframework/cloud/dataflow/common/test/docker/junit5/docker-compose-cp1.yml
@@ -0,0 +1,4 @@
+services:
+ testservice1:
+ image: 'springcloud/openjdk:latest'
+ command: sh -c 'sleep 60'
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/pom.xml b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/pom.xml
new file mode 100644
index 0000000000..efdf8e931d
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/pom.xml
@@ -0,0 +1,60 @@
+
+
+ 4.0.0
+
+ spring-cloud-dataflow-common-test-docker
+ jar
+
+ Spring Cloud Dataflow Common Docker Test Support
+ Utilities to help using docker
+
+
+ org.springframework.cloud
+ spring-cloud-dataflow-common-parent
+ 3.0.0-SNAPSHOT
+
+
+ true
+
+
+
+ org.springframework
+ spring-core
+
+
+ commons-io
+ commons-io
+
+
+ org.apache.commons
+ commons-lang3
+
+
+ org.slf4j
+ slf4j-api
+
+
+ org.awaitility
+ awaitility
+
+
+ joda-time
+ joda-time
+
+
+ com.github.zafarkhaja
+ java-semver
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+ junit
+ junit
+ test
+
+
+
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/DockerComposeRule.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/DockerComposeRule.java
new file mode 100644
index 0000000000..448a116b06
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/DockerComposeRule.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2018-2021 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.cloud.dataflow.common.test.docker.compose;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.joda.time.Duration;
+import org.joda.time.ReadableDuration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.DockerComposeFiles;
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.ProjectName;
+import org.springframework.cloud.dataflow.common.test.docker.compose.configuration.ShutdownStrategy;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.Cluster;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.Container;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.ContainerCache;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.DockerMachine;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.DockerPort;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.ClusterHealthCheck;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.ClusterWait;
+import org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.HealthCheck;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.ConflictingContainerRemovingDockerCompose;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DefaultDockerCompose;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.Docker;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerCompose;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerComposeExecArgument;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerComposeExecOption;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerComposeExecutable;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerComposeRunArgument;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerComposeRunOption;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.DockerExecutable;
+import org.springframework.cloud.dataflow.common.test.docker.compose.execution.RetryingDockerCompose;
+import org.springframework.cloud.dataflow.common.test.docker.compose.logging.DoNothingLogCollector;
+import org.springframework.cloud.dataflow.common.test.docker.compose.logging.FileLogCollector;
+import org.springframework.cloud.dataflow.common.test.docker.compose.logging.LogCollector;
+import org.springframework.cloud.dataflow.common.test.docker.compose.logging.LogDirectory;
+
+import static org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.ClusterHealthCheck.serviceHealthCheck;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.connection.waiting.ClusterHealthCheck.transformingHealthCheck;
+
+public class DockerComposeRule {
+
+ public static final Duration DEFAULT_TIMEOUT = Duration.standardMinutes(2);
+ public static final int DEFAULT_RETRY_ATTEMPTS = 2;
+ private ProjectName projectName;
+
+ private static final Logger log = LoggerFactory.getLogger(DockerComposeRule.class);
+
+ public DockerPort hostNetworkedPort(int port) {
+ return new DockerPort(machine().getIp(), port, port);
+ }
+
+ private DockerComposeFiles files;
+ private List clusterWaits;
+ private LogCollector logCollector;
+ private DockerMachine machine;
+ private boolean pullOnStartup;
+
+ protected DockerComposeRule() {}
+
+ public DockerComposeRule(DockerComposeFiles files, List clusterWaits, LogCollector logCollector,
+ DockerMachine machine, boolean pullOnStartup, ProjectName projectName) {
+ super();
+ this.files = files;
+ this.clusterWaits = clusterWaits;
+ this.logCollector = logCollector;
+ this.machine = machine;
+ this.pullOnStartup = pullOnStartup;
+ this.projectName = projectName != null ? projectName : ProjectName.random();
+ }
+
+ public DockerComposeFiles files() {
+ return files;
+ }
+
+ public List clusterWaits() {
+ return clusterWaits;
+ }
+
+ public DockerMachine machine() {
+ return machine != null ? machine : DockerMachine.localMachine().build();
+ }
+
+ public ProjectName projectName() {
+ return projectName;
+ }
+
+ public DockerComposeExecutable dockerComposeExecutable() {
+ return DockerComposeExecutable.builder()
+ .dockerComposeFiles(files())
+ .dockerConfiguration(machine())
+ .projectName(projectName())
+ .build();
+ }
+
+ public DockerExecutable dockerExecutable() {
+ return DockerExecutable.builder()
+ .dockerConfiguration(machine())
+ .build();
+ }
+
+ public Docker docker() {
+ return new Docker(dockerExecutable());
+ }
+
+ public ShutdownStrategy shutdownStrategy() {
+ return ShutdownStrategy.KILL_DOWN;
+ }
+
+ public DockerCompose dockerCompose() {
+ DockerCompose dockerCompose = new DefaultDockerCompose(dockerComposeExecutable(), machine());
+ return new RetryingDockerCompose(retryAttempts(), dockerCompose);
+ }
+
+ public Cluster containers() {
+ return Cluster.builder()
+ .ip(machine().getIp())
+ .containerCache(new ContainerCache(docker(), dockerCompose()))
+ .build();
+ }
+
+ protected int retryAttempts() {
+ return DEFAULT_RETRY_ATTEMPTS;
+ }
+
+ protected boolean removeConflictingContainersOnStartup() {
+ return true;
+ }
+
+ protected boolean pullOnStartup() {
+ return pullOnStartup;
+ }
+
+ protected ReadableDuration nativeServiceHealthCheckTimeout() {
+ return DEFAULT_TIMEOUT;
+ }
+
+ protected LogCollector logCollector() {
+ return logCollector != null ? logCollector : new DoNothingLogCollector();
+ }
+
+ public void before() throws IOException, InterruptedException {
+ log.debug("Starting docker-compose cluster");
+ if (pullOnStartup()) {
+ dockerCompose().pull();
+ }
+
+ dockerCompose().build();
+
+ DockerCompose upDockerCompose = dockerCompose();
+ if (removeConflictingContainersOnStartup()) {
+ upDockerCompose = new ConflictingContainerRemovingDockerCompose(upDockerCompose, docker());
+ }
+ upDockerCompose.up();
+
+ logCollector().startCollecting(dockerCompose());
+ log.debug("Waiting for services");
+ new ClusterWait(ClusterHealthCheck.nativeHealthChecks(), nativeServiceHealthCheckTimeout())
+ .waitUntilReady(containers());
+ clusterWaits().forEach(clusterWait -> clusterWait.waitUntilReady(containers()));
+ log.debug("docker-compose cluster started");
+ }
+
+ public void after() {
+ try {
+ shutdownStrategy().shutdown(this.dockerCompose(), this.docker());
+ logCollector().stopCollecting();
+ } catch (IOException | InterruptedException e) {
+ throw new RuntimeException("Error cleaning up docker compose cluster", e);
+ }
+ }
+
+ public String exec(DockerComposeExecOption options, String containerName,
+ DockerComposeExecArgument arguments) throws IOException, InterruptedException {
+ return dockerCompose().exec(options, containerName, arguments);
+ }
+
+ public String run(DockerComposeRunOption options, String containerName,
+ DockerComposeRunArgument arguments) throws IOException, InterruptedException {
+ return dockerCompose().run(options, containerName, arguments);
+ }
+
+ public static Builder builder() {
+ return new Builder<>();
+ }
+
+ public static class Builder> {
+
+ protected DockerComposeFiles files;
+ protected List clusterWaits = new ArrayList<>();
+ protected LogCollector logCollector;
+ protected DockerMachine machine;
+ protected boolean pullOnStartup;
+ protected ProjectName projectName;
+
+ public T files(DockerComposeFiles files) {
+ this.files = files;
+ return self();
+ }
+
+ public T file(String dockerComposeYmlFile) {
+ return files(DockerComposeFiles.from(dockerComposeYmlFile));
+ }
+
+ /**
+ * Save the output of docker logs to files, stored in the path directory.
+ *
+ * See {@link LogDirectory} for some useful utilities, for example:
+ * {@link LogDirectory#circleAwareLogDirectory}.
+ *
+ * @param path directory into which log files should be saved
+ * @return builder for chaining
+ */
+ public T saveLogsTo(String path) {
+ return logCollector(FileLogCollector.fromPath(path));
+ }
+
+ public T logCollector(LogCollector logCollector) {
+ this.logCollector = logCollector;
+ return self();
+ }
+
+ public T waitingForService(String serviceName, HealthCheck healthCheck, ReadableDuration timeout) {
+ ClusterHealthCheck clusterHealthCheck = serviceHealthCheck(serviceName, healthCheck);
+ return addClusterWait(new ClusterWait(clusterHealthCheck, timeout));
+ }
+
+ private T addClusterWait(ClusterWait clusterWait) {
+ clusterWaits.add(clusterWait);
+ return self();
+ }
+
+ public T waitingForServices(List services, HealthCheck> healthCheck) {
+ return waitingForServices(services, healthCheck, DEFAULT_TIMEOUT);
+ }
+
+ public T waitingForServices(List services, HealthCheck> healthCheck, ReadableDuration timeout) {
+ ClusterHealthCheck clusterHealthCheck = serviceHealthCheck(services, healthCheck);
+ return addClusterWait(new ClusterWait(clusterHealthCheck, timeout));
+ }
+
+ public T waitingForHostNetworkedPort(int port, HealthCheck healthCheck) {
+ return waitingForHostNetworkedPort(port, healthCheck, DEFAULT_TIMEOUT);
+ }
+
+ public T waitingForHostNetworkedPort(int port, HealthCheck healthCheck, ReadableDuration timeout) {
+ ClusterHealthCheck clusterHealthCheck = transformingHealthCheck(cluster -> new DockerPort(cluster.ip(), port, port), healthCheck);
+ return addClusterWait(new ClusterWait(clusterHealthCheck, timeout));
+ }
+
+ public T clusterWaits(Iterable elements) {
+ elements.forEach(e -> clusterWaits.add(e));
+ return self();
+ }
+
+ public T machine(DockerMachine machine) {
+ this.machine = machine;
+ return self();
+ }
+
+ public T pullOnStartup(boolean pullOnStartup) {
+ this.pullOnStartup = pullOnStartup;
+ return self();
+ }
+
+ public T projectName(ProjectName projectName) {
+ this.projectName = projectName;
+ return self();
+ }
+
+ @SuppressWarnings("unchecked")
+ final T self() {
+ return (T) this;
+ }
+
+ public DockerComposeRule build() {
+ return new DockerComposeRule(files, clusterWaits, logCollector, machine, pullOnStartup, projectName);
+ }
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/AdditionalEnvironmentValidator.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/AdditionalEnvironmentValidator.java
new file mode 100644
index 0000000000..aad7b918e9
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/AdditionalEnvironmentValidator.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.compose.configuration;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.util.Assert;
+
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_CERT_PATH;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_HOST;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_TLS_VERIFY;
+
+public final class AdditionalEnvironmentValidator {
+
+ private static final Set ILLEGAL_VARIABLES = new HashSet<>(Arrays.asList(DOCKER_TLS_VERIFY, DOCKER_HOST, DOCKER_CERT_PATH));
+
+ private AdditionalEnvironmentValidator() {}
+
+ public static Map validate(Map additionalEnvironment) {
+ HashSet invalidVariables = new HashSet<>(additionalEnvironment.keySet());
+ invalidVariables.retainAll(ILLEGAL_VARIABLES);
+
+ String errorMessage = invalidVariables.stream()
+ .collect(Collectors.joining(", ",
+ "The following variables: ",
+ " cannot exist in your additional environment variable block as they will interfere with Docker."));
+ Assert.state(invalidVariables.isEmpty(), errorMessage);
+ return additionalEnvironment;
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonEnvironmentValidator.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonEnvironmentValidator.java
new file mode 100644
index 0000000000..084a2c9334
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonEnvironmentValidator.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.compose.configuration;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.util.Assert;
+
+import static java.util.stream.Collectors.joining;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_CERT_PATH;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_HOST;
+import static org.springframework.cloud.dataflow.common.test.docker.compose.configuration.EnvironmentVariables.DOCKER_TLS_VERIFY;
+
+public class DaemonEnvironmentValidator implements EnvironmentValidator {
+
+ private static final Set ILLEGAL_VARIABLES = new HashSet<>(Arrays.asList(DOCKER_TLS_VERIFY, DOCKER_HOST, DOCKER_CERT_PATH));
+
+ private static final DaemonEnvironmentValidator INSTANCE = new DaemonEnvironmentValidator();
+
+ public static DaemonEnvironmentValidator instance() {
+ return INSTANCE;
+ }
+
+ private DaemonEnvironmentValidator() {}
+
+ @Override
+ public void validateEnvironmentVariables(Map dockerEnvironment) {
+ Set invalidVariables = ILLEGAL_VARIABLES.stream()
+ .filter(dockerEnvironment::containsKey)
+ .collect(Collectors.toSet());
+
+ String errorMessage = invalidVariables.stream()
+ .collect(joining(", ",
+ "These variables were set: ",
+ ". They cannot be set when connecting to a local docker daemon."));
+ Assert.state(invalidVariables.isEmpty(), errorMessage);
+ }
+
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonHostIpResolver.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonHostIpResolver.java
new file mode 100644
index 0000000000..2917b70aae
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DaemonHostIpResolver.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2018-2019 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.cloud.dataflow.common.test.docker.compose.configuration;
+
+public class DaemonHostIpResolver implements HostIpResolver {
+
+ public static final String LOCALHOST = "127.0.0.1";
+
+ @Override
+ public String resolveIp(String dockerHost) {
+ return LOCALHOST;
+ }
+}
diff --git a/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DockerComposeFiles.java b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DockerComposeFiles.java
new file mode 100644
index 0000000000..8427cc0b76
--- /dev/null
+++ b/spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/main/java/org/springframework/cloud/dataflow/common/test/docker/compose/configuration/DockerComposeFiles.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2018-2020 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.cloud.dataflow.common.test.docker.compose.configuration;
+
+import java.io.File;
+import java.net.URL;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.springframework.util.Assert;
+
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+
+public class DockerComposeFiles {
+
+ private final List
- 
-