Merge branch 'gh-35544'

Closes gh-35544
This commit is contained in:
Phillip Webb 2023-05-17 16:20:48 -07:00
commit d018aa8f6d
17 changed files with 125 additions and 348 deletions

View File

@ -31,7 +31,6 @@ import org.springframework.boot.docker.compose.core.DockerComposeFile;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
import org.springframework.boot.docker.compose.lifecycle.DockerComposeProperties.Start; import org.springframework.boot.docker.compose.lifecycle.DockerComposeProperties.Start;
import org.springframework.boot.docker.compose.lifecycle.DockerComposeProperties.Stop; import org.springframework.boot.docker.compose.lifecycle.DockerComposeProperties.Stop;
import org.springframework.boot.docker.compose.readiness.ServiceReadinessChecks;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener; import org.springframework.context.ApplicationListener;
import org.springframework.context.event.SimpleApplicationEventMulticaster; import org.springframework.context.event.SimpleApplicationEventMulticaster;
@ -88,7 +87,7 @@ class DockerComposeLifecycleManager {
this.eventListeners = eventListeners; this.eventListeners = eventListeners;
this.skipCheck = skipCheck; this.skipCheck = skipCheck;
this.serviceReadinessChecks = (serviceReadinessChecks != null) ? serviceReadinessChecks this.serviceReadinessChecks = (serviceReadinessChecks != null) ? serviceReadinessChecks
: new ServiceReadinessChecks(this.classLoader, applicationContext.getEnvironment(), binder); : new ServiceReadinessChecks(properties.getReadiness());
} }
void start() { void start() {

View File

@ -75,6 +75,8 @@ public class DockerComposeProperties {
private final Skip skip = new Skip(); private final Skip skip = new Skip();
private final Readiness readiness = new Readiness();
public boolean isEnabled() { public boolean isEnabled() {
return this.enabled; return this.enabled;
} }
@ -123,6 +125,10 @@ public class DockerComposeProperties {
return this.skip; return this.skip;
} }
public Readiness getReadiness() {
return this.readiness;
}
static DockerComposeProperties get(Binder binder) { static DockerComposeProperties get(Binder binder) {
return binder.bind(NAME, DockerComposeProperties.class).orElseGet(DockerComposeProperties::new); return binder.bind(NAME, DockerComposeProperties.class).orElseGet(DockerComposeProperties::new);
} }
@ -233,4 +239,66 @@ public class DockerComposeProperties {
} }
/**
* Readiness properties.
*/
public static class Readiness {
/**
* Timeout of the readiness checks.
*/
private Duration timeout = Duration.ofMinutes(2);
/**
* TCP properties.
*/
private final Tcp tcp = new Tcp();
public Duration getTimeout() {
return this.timeout;
}
public void setTimeout(Duration timeout) {
this.timeout = timeout;
}
public Tcp getTcp() {
return this.tcp;
}
/**
* TCP properties.
*/
public static class Tcp {
/**
* Timeout for connections.
*/
private Duration connectTimeout = Duration.ofMillis(200);
/**
* Timeout for reads.
*/
private Duration readTimeout = Duration.ofMillis(200);
public Duration getConnectTimeout() {
return this.connectTimeout;
}
public void setConnectTimeout(Duration connectTimeout) {
this.connectTimeout = connectTimeout;
}
public Duration getReadTimeout() {
return this.readTimeout;
}
public void setReadTimeout(Duration readTimeout) {
this.readTimeout = readTimeout;
}
}
}
} }

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.time.Duration; import java.time.Duration;
import java.util.List; import java.util.List;
@ -23,9 +23,7 @@ import java.util.Objects;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
/** /**
* Exception thrown if readiness checking has timed out. Related * Exception thrown if readiness checking has timed out.
* {@link ServiceNotReadyException ServiceNotReadyExceptions} are available from
* {@link #getSuppressed()}.
* *
* @author Moritz Halbritter * @author Moritz Halbritter
* @author Andy Wilkinson * @author Andy Wilkinson

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
@ -24,10 +24,8 @@ import org.springframework.boot.docker.compose.core.RunningService;
* @author Moritz Halbritter * @author Moritz Halbritter
* @author Andy Wilkinson * @author Andy Wilkinson
* @author Phillip Webb * @author Phillip Webb
* @since 3.1.0
* @see ServiceReadinessCheck
*/ */
public class ServiceNotReadyException extends RuntimeException { class ServiceNotReadyException extends RuntimeException {
private final RunningService service; private final RunningService service;
@ -40,11 +38,7 @@ public class ServiceNotReadyException extends RuntimeException {
this.service = service; this.service = service;
} }
/** RunningService getService() {
* Return the service that was not ready.
* @return the non-ready service
*/
public RunningService getService() {
return this.service; return this.service;
} }

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.time.Clock; import java.time.Clock;
import java.time.Duration; import java.time.Duration;
@ -23,28 +23,21 @@ import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Function;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.core.io.support.SpringFactoriesLoader.ArgumentResolver;
import org.springframework.core.log.LogMessage; import org.springframework.core.log.LogMessage;
/** /**
* A collection of {@link ServiceReadinessCheck} instances that can be used to * Utility used to {@link #wait() wait} for {@link RunningService services} to be ready.
* {@link #wait() wait} for {@link RunningService services} to be ready.
* *
* @author Moritz Halbritter * @author Moritz Halbritter
* @author Andy Wilkinson * @author Andy Wilkinson
* @author Phillip Webb * @author Phillip Webb
* @since 3.1.0
*/ */
public class ServiceReadinessChecks { class ServiceReadinessChecks {
private static final Log logger = LogFactory.getLog(ServiceReadinessChecks.class); private static final Log logger = LogFactory.getLog(ServiceReadinessChecks.class);
@ -56,34 +49,28 @@ public class ServiceReadinessChecks {
private final Consumer<Duration> sleep; private final Consumer<Duration> sleep;
private final ReadinessProperties properties; private final DockerComposeProperties.Readiness properties;
private final List<ServiceReadinessCheck> checks; private final TcpConnectServiceReadinessCheck check;
public ServiceReadinessChecks(ClassLoader classLoader, Environment environment, Binder binder) { ServiceReadinessChecks(DockerComposeProperties.Readiness properties) {
this(Clock.systemUTC(), ServiceReadinessChecks::sleep, this(properties, Clock.systemUTC(), ServiceReadinessChecks::sleep,
SpringFactoriesLoader.forDefaultResourceLocation(classLoader), classLoader, environment, binder, new TcpConnectServiceReadinessCheck(properties.getTcp()));
TcpConnectServiceReadinessCheck::new);
} }
ServiceReadinessChecks(Clock clock, Consumer<Duration> sleep, SpringFactoriesLoader loader, ClassLoader classLoader, ServiceReadinessChecks(DockerComposeProperties.Readiness properties, Clock clock, Consumer<Duration> sleep,
Environment environment, Binder binder, TcpConnectServiceReadinessCheck check) {
Function<ReadinessProperties.Tcp, ServiceReadinessCheck> tcpCheckFactory) {
ArgumentResolver argumentResolver = ArgumentResolver.of(ClassLoader.class, classLoader)
.and(Environment.class, environment)
.and(Binder.class, binder);
this.clock = clock; this.clock = clock;
this.sleep = sleep; this.sleep = sleep;
this.properties = ReadinessProperties.get(binder); this.properties = properties;
this.checks = new ArrayList<>(loader.load(ServiceReadinessCheck.class, argumentResolver)); this.check = check;
this.checks.add(tcpCheckFactory.apply(this.properties.getTcp()));
} }
/** /**
* Wait for the given services to be ready. * Wait for the given services to be ready.
* @param runningServices the services to wait for * @param runningServices the services to wait for
*/ */
public void waitUntilReady(List<RunningService> runningServices) { void waitUntilReady(List<RunningService> runningServices) {
Duration timeout = this.properties.getTimeout(); Duration timeout = this.properties.getTimeout();
Instant start = this.clock.instant(); Instant start = this.clock.instant();
while (true) { while (true) {
@ -106,9 +93,8 @@ public class ServiceReadinessChecks {
continue; continue;
} }
logger.trace(LogMessage.format("Checking readiness of service '%s'", service)); logger.trace(LogMessage.format("Checking readiness of service '%s'", service));
for (ServiceReadinessCheck check : this.checks) {
try { try {
check.check(service); this.check.check(service);
logger.trace(LogMessage.format("Service '%s' is ready", service)); logger.trace(LogMessage.format("Service '%s' is ready", service));
} }
catch (ServiceNotReadyException ex) { catch (ServiceNotReadyException ex) {
@ -117,7 +103,6 @@ public class ServiceReadinessChecks {
exceptions.add(ex); exceptions.add(ex);
} }
} }
}
return (exceptions != null) ? exceptions : Collections.emptyList(); return (exceptions != null) ? exceptions : Collections.emptyList();
} }

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.io.IOException; import java.io.IOException;
import java.net.InetSocketAddress; import java.net.InetSocketAddress;
@ -24,25 +24,23 @@ import java.net.SocketTimeoutException;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
/** /**
* Default {@link ServiceReadinessCheck} that checks readiness by connecting to the * Checks readiness by connecting to the exposed TCP ports.
* exposed TCP ports.
* *
* @author Moritz Halbritter * @author Moritz Halbritter
* @author Andy Wilkinson * @author Andy Wilkinson
* @author Phillip Webb * @author Phillip Webb
*/ */
class TcpConnectServiceReadinessCheck implements ServiceReadinessCheck { class TcpConnectServiceReadinessCheck {
private static final String DISABLE_LABEL = "org.springframework.boot.readiness-check.tcp.disable"; private static final String DISABLE_LABEL = "org.springframework.boot.readiness-check.tcp.disable";
private final ReadinessProperties.Tcp properties; private final DockerComposeProperties.Readiness.Tcp properties;
TcpConnectServiceReadinessCheck(ReadinessProperties.Tcp properties) { TcpConnectServiceReadinessCheck(DockerComposeProperties.Readiness.Tcp properties) {
this.properties = properties; this.properties = properties;
} }
@Override void check(RunningService service) {
public void check(RunningService service) {
if (service.labels().containsKey(DISABLE_LABEL)) { if (service.labels().containsKey(DISABLE_LABEL)) {
return; return;
} }

View File

@ -1,101 +0,0 @@
/*
* Copyright 2012-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.boot.docker.compose.readiness;
import java.time.Duration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.bind.Binder;
/**
* Readiness configuration properties.
*
* @author Moritz Halbritter
* @author Andy Wilkinson
* @author Phillip Webb
* @since 3.1.0
*/
@ConfigurationProperties(ReadinessProperties.NAME)
public class ReadinessProperties {
static final String NAME = "spring.docker.compose.readiness";
/**
* Timeout of the readiness checks.
*/
private Duration timeout = Duration.ofMinutes(2);
/**
* TCP properties.
*/
private final Tcp tcp = new Tcp();
public Duration getTimeout() {
return this.timeout;
}
public void setTimeout(Duration timeout) {
this.timeout = timeout;
}
public Tcp getTcp() {
return this.tcp;
}
/**
* Get the properties using the given binder.
* @param binder the binder used to get the properties
* @return a bound {@link ReadinessProperties} instance
*/
static ReadinessProperties get(Binder binder) {
return binder.bind(ReadinessProperties.NAME, ReadinessProperties.class).orElseGet(ReadinessProperties::new);
}
/**
* TCP properties.
*/
public static class Tcp {
/**
* Timeout for connections.
*/
private Duration connectTimeout = Duration.ofMillis(200);
/**
* Timeout for reads.
*/
private Duration readTimeout = Duration.ofMillis(200);
public Duration getConnectTimeout() {
return this.connectTimeout;
}
public void setConnectTimeout(Duration connectTimeout) {
this.connectTimeout = connectTimeout;
}
public Duration getReadTimeout() {
return this.readTimeout;
}
public void setReadTimeout(Duration readTimeout) {
this.readTimeout = readTimeout;
}
}
}

View File

@ -1,47 +0,0 @@
/*
* Copyright 2012-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.boot.docker.compose.readiness;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.docker.compose.core.RunningService;
import org.springframework.core.env.Environment;
/**
* Strategy used to check if a {@link RunningService} is ready. Implementations may be
* registered in {@code spring.factories}. The following constructor arguments types are
* supported:
* <ul>
* <li>{@link ClassLoader}</li>
* <li>{@link Environment}</li>
* <li>{@link Binder}</li>
* </ul>
*
* @author Moritz Halbritter
* @author Andy Wilkinson
* @author Phillip Webb
* @since 3.1.0
*/
public interface ServiceReadinessCheck {
/**
* Checks whether the given {@code service} is ready.
* @param service service to check
* @throws ServiceNotReadyException if the service is not ready
*/
void check(RunningService service) throws ServiceNotReadyException;
}

View File

@ -1,20 +0,0 @@
/*
* Copyright 2012-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.
*/
/**
* Service readiness checks.
*/
package org.springframework.boot.docker.compose.readiness;

View File

@ -36,7 +36,6 @@ import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.docker.compose.core.DockerCompose; import org.springframework.boot.docker.compose.core.DockerCompose;
import org.springframework.boot.docker.compose.core.DockerComposeFile; import org.springframework.boot.docker.compose.core.DockerComposeFile;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
import org.springframework.boot.docker.compose.readiness.ServiceReadinessChecks;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener; import org.springframework.context.ApplicationListener;
import org.springframework.context.support.GenericApplicationContext; import org.springframework.context.support.GenericApplicationContext;

View File

@ -48,6 +48,9 @@ class DockerComposePropertiesTests {
assertThat(properties.getStop().getCommand()).isEqualTo(StopCommand.STOP); assertThat(properties.getStop().getCommand()).isEqualTo(StopCommand.STOP);
assertThat(properties.getStop().getTimeout()).isEqualTo(Duration.ofSeconds(10)); assertThat(properties.getStop().getTimeout()).isEqualTo(Duration.ofSeconds(10));
assertThat(properties.getProfiles().getActive()).isEmpty(); assertThat(properties.getProfiles().getActive()).isEmpty();
assertThat(properties.getReadiness().getTimeout()).isEqualTo(Duration.ofMinutes(2));
assertThat(properties.getReadiness().getTcp().getConnectTimeout()).isEqualTo(Duration.ofMillis(200));
assertThat(properties.getReadiness().getTcp().getReadTimeout()).isEqualTo(Duration.ofMillis(200));
} }
@Test @Test
@ -60,6 +63,9 @@ class DockerComposePropertiesTests {
source.put("spring.docker.compose.stop.command", "down"); source.put("spring.docker.compose.stop.command", "down");
source.put("spring.docker.compose.stop.timeout", "5s"); source.put("spring.docker.compose.stop.timeout", "5s");
source.put("spring.docker.compose.profiles.active", "myprofile"); source.put("spring.docker.compose.profiles.active", "myprofile");
source.put("spring.docker.compose.readiness.timeout", "10s");
source.put("spring.docker.compose.readiness.tcp.connect-timeout", "400ms");
source.put("spring.docker.compose.readiness.tcp.read-timeout", "500ms");
Binder binder = new Binder(new MapConfigurationPropertySource(source)); Binder binder = new Binder(new MapConfigurationPropertySource(source));
DockerComposeProperties properties = DockerComposeProperties.get(binder); DockerComposeProperties properties = DockerComposeProperties.get(binder);
assertThat(properties.getFile()).isEqualTo(new File("my-compose.yml")); assertThat(properties.getFile()).isEqualTo(new File("my-compose.yml"));
@ -69,6 +75,9 @@ class DockerComposePropertiesTests {
assertThat(properties.getStop().getCommand()).isEqualTo(StopCommand.DOWN); assertThat(properties.getStop().getCommand()).isEqualTo(StopCommand.DOWN);
assertThat(properties.getStop().getTimeout()).isEqualTo(Duration.ofSeconds(5)); assertThat(properties.getStop().getTimeout()).isEqualTo(Duration.ofSeconds(5));
assertThat(properties.getProfiles().getActive()).containsExactly("myprofile"); assertThat(properties.getProfiles().getActive()).containsExactly("myprofile");
assertThat(properties.getReadiness().getTimeout()).isEqualTo(Duration.ofSeconds(10));
assertThat(properties.getReadiness().getTcp().getConnectTimeout()).isEqualTo(Duration.ofMillis(400));
assertThat(properties.getReadiness().getTcp().getReadTimeout()).isEqualTo(Duration.ofMillis(500));
} }
} }

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.time.Duration; import java.time.Duration;
import java.util.List; import java.util.List;

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.time.Clock; import java.time.Clock;
import java.time.Duration; import java.time.Duration;
@ -25,22 +25,13 @@ import java.util.Map;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.docker.compose.core.RunningService; import org.springframework.boot.docker.compose.core.RunningService;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.SpringFactoriesLoader.ArgumentResolver;
import org.springframework.core.test.io.support.MockSpringFactoriesLoader;
import org.springframework.mock.env.MockEnvironment;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
/** /**
* Tests for {@link ServiceReadinessChecks}. * Tests for {@link ServiceReadinessChecks}.
@ -55,68 +46,37 @@ class ServiceReadinessChecksTests {
Instant now = Instant.now(); Instant now = Instant.now();
private MockSpringFactoriesLoader loader;
private ClassLoader classLoader;
private MockEnvironment environment;
private Binder binder;
private RunningService runningService; private RunningService runningService;
private List<RunningService> runningServices; private List<RunningService> runningServices;
private final MockServiceReadinessCheck mockTcpCheck = new MockServiceReadinessCheck();
@BeforeEach @BeforeEach
void setup() { void setup() {
this.clock = mock(Clock.class); this.clock = mock(Clock.class);
given(this.clock.instant()).willAnswer((args) -> this.now); given(this.clock.instant()).willAnswer((args) -> this.now);
this.loader = new MockSpringFactoriesLoader();
this.classLoader = getClass().getClassLoader();
this.environment = new MockEnvironment();
this.binder = Binder.get(this.environment);
this.runningService = mock(RunningService.class); this.runningService = mock(RunningService.class);
this.runningServices = List.of(this.runningService); this.runningServices = List.of(this.runningService);
} }
@Test
void loadCanResolveArguments() {
this.loader = spy(MockSpringFactoriesLoader.class);
createChecks();
then(this.loader).should()
.load(eq(ServiceReadinessCheck.class), ArgumentMatchers.<ArgumentResolver>assertArg((argumentResolver) -> {
assertThat(argumentResolver.resolve(ClassLoader.class)).isEqualTo(this.classLoader);
assertThat(argumentResolver.resolve(Environment.class)).isEqualTo(this.environment);
assertThat(argumentResolver.resolve(Binder.class)).isEqualTo(this.binder);
}));
}
@Test @Test
void waitUntilReadyWhenImmediatelyReady() { void waitUntilReadyWhenImmediatelyReady() {
MockServiceReadinessCheck check = new MockServiceReadinessCheck(); MockServiceReadinessCheck check = new MockServiceReadinessCheck();
this.loader.addInstance(ServiceReadinessCheck.class, check); createChecks(check).waitUntilReady(this.runningServices);
createChecks().waitUntilReady(this.runningServices);
assertThat(check.getChecked()).contains(this.runningService); assertThat(check.getChecked()).contains(this.runningService);
assertThat(this.mockTcpCheck.getChecked()).contains(this.runningService);
} }
@Test @Test
void waitUntilReadyWhenTakesTimeToBeReady() { void waitUntilReadyWhenTakesTimeToBeReady() {
MockServiceReadinessCheck check = new MockServiceReadinessCheck(2); MockServiceReadinessCheck check = new MockServiceReadinessCheck(2);
this.loader.addInstance(ServiceReadinessCheck.class, check); createChecks(check).waitUntilReady(this.runningServices);
createChecks().waitUntilReady(this.runningServices);
assertThat(check.getChecked()).hasSize(2).contains(this.runningService); assertThat(check.getChecked()).hasSize(2).contains(this.runningService);
assertThat(this.mockTcpCheck.getChecked()).contains(this.runningService);
} }
@Test @Test
void waitUntilReadyWhenTimeout() { void waitUntilReadyWhenTimeout() {
MockServiceReadinessCheck check = new MockServiceReadinessCheck(Integer.MAX_VALUE); MockServiceReadinessCheck check = new MockServiceReadinessCheck(Integer.MAX_VALUE);
this.loader.addInstance(ServiceReadinessCheck.class, check);
assertThatExceptionOfType(ReadinessTimeoutException.class) assertThatExceptionOfType(ReadinessTimeoutException.class)
.isThrownBy(() -> createChecks().waitUntilReady(this.runningServices)) .isThrownBy(() -> createChecks(check).waitUntilReady(this.runningServices))
.satisfies((ex) -> assertThat(ex.getSuppressed()).hasSize(1)); .satisfies((ex) -> assertThat(ex.getSuppressed()).hasSize(1));
assertThat(check.getChecked()).hasSizeGreaterThan(10); assertThat(check.getChecked()).hasSizeGreaterThan(10);
} }
@ -125,25 +85,23 @@ class ServiceReadinessChecksTests {
void waitForWhenServiceHasDisableLabelDoesNotCheck() { void waitForWhenServiceHasDisableLabelDoesNotCheck() {
given(this.runningService.labels()).willReturn(Map.of("org.springframework.boot.readiness-check.disable", "")); given(this.runningService.labels()).willReturn(Map.of("org.springframework.boot.readiness-check.disable", ""));
MockServiceReadinessCheck check = new MockServiceReadinessCheck(); MockServiceReadinessCheck check = new MockServiceReadinessCheck();
this.loader.addInstance(ServiceReadinessCheck.class, check); createChecks(check).waitUntilReady(this.runningServices);
createChecks().waitUntilReady(this.runningServices);
assertThat(check.getChecked()).isEmpty(); assertThat(check.getChecked()).isEmpty();
assertThat(this.mockTcpCheck.getChecked()).isEmpty();
} }
void sleep(Duration duration) { void sleep(Duration duration) {
this.now = this.now.plus(duration); this.now = this.now.plus(duration);
} }
private ServiceReadinessChecks createChecks() { private ServiceReadinessChecks createChecks(TcpConnectServiceReadinessCheck check) {
return new ServiceReadinessChecks(this.clock, this::sleep, this.loader, this.classLoader, this.environment, DockerComposeProperties properties = new DockerComposeProperties();
this.binder, (properties) -> this.mockTcpCheck); return new ServiceReadinessChecks(properties.getReadiness(), this.clock, this::sleep, check);
} }
/** /**
* Mock {@link ServiceReadinessCheck}. * Mock {@link TcpConnectServiceReadinessCheck}.
*/ */
static class MockServiceReadinessCheck implements ServiceReadinessCheck { static class MockServiceReadinessCheck extends TcpConnectServiceReadinessCheck {
private final Integer failUntil; private final Integer failUntil;
@ -154,6 +112,7 @@ class ServiceReadinessChecksTests {
} }
MockServiceReadinessCheck(Integer failUntil) { MockServiceReadinessCheck(Integer failUntil) {
super(null);
this.failUntil = failUntil; this.failUntil = failUntil;
} }

View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package org.springframework.boot.docker.compose.readiness; package org.springframework.boot.docker.compose.lifecycle;
import java.io.IOException; import java.io.IOException;
import java.io.UncheckedIOException; import java.io.UncheckedIOException;
@ -50,7 +50,7 @@ class TcpConnectServiceReadinessCheckTests {
@BeforeEach @BeforeEach
void setup() { void setup() {
ReadinessProperties.Tcp tcpProperties = new ReadinessProperties.Tcp(); DockerComposeProperties.Readiness.Tcp tcpProperties = new DockerComposeProperties.Readiness.Tcp();
tcpProperties.setConnectTimeout(Duration.ofMillis(100)); tcpProperties.setConnectTimeout(Duration.ofMillis(100));
tcpProperties.setReadTimeout(Duration.ofMillis(100)); tcpProperties.setReadTimeout(Duration.ofMillis(100));
this.readinessCheck = new TcpConnectServiceReadinessCheck(tcpProperties); this.readinessCheck = new TcpConnectServiceReadinessCheck(tcpProperties);

View File

@ -1,62 +0,0 @@
/*
* Copyright 2012-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.boot.docker.compose.readiness;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ReadinessProperties}.
*
* @author Moritz Halbritter
* @author Andy Wilkinson
* @author Phillip Webb
*/
class ReadinessPropertiesTests {
@Test
void getWhenNoPropertiesReturnsNewInstance() {
Binder binder = new Binder(new MapConfigurationPropertySource());
ReadinessProperties properties = ReadinessProperties.get(binder);
assertThat(properties.getTimeout()).isEqualTo(Duration.ofMinutes(2));
assertThat(properties.getTcp().getConnectTimeout()).isEqualTo(Duration.ofMillis(200));
assertThat(properties.getTcp().getReadTimeout()).isEqualTo(Duration.ofMillis(200));
}
@Test
void getWhenPropertiesReturnsBoundInstance() {
Map<String, String> source = new LinkedHashMap<>();
source.put("spring.docker.compose.readiness.timeout", "10s");
source.put("spring.docker.compose.readiness.tcp.connect-timeout", "400ms");
source.put("spring.docker.compose.readiness.tcp.read-timeout", "500ms");
Binder binder = new Binder(new MapConfigurationPropertySource(source));
ReadinessProperties properties = ReadinessProperties.get(binder);
assertThat(properties.getTimeout()).isEqualTo(Duration.ofSeconds(10));
assertThat(properties.getTcp().getConnectTimeout()).isEqualTo(Duration.ofMillis(400));
assertThat(properties.getTcp().getReadTimeout()).isEqualTo(Duration.ofMillis(500));
}
}

View File

@ -184,8 +184,6 @@ You can also change timeout values in your `application.properties` or `applicat
The overall timeout can be configured using configprop:spring.docker.compose.readiness.timeout[]. The overall timeout can be configured using configprop:spring.docker.compose.readiness.timeout[].
TIP: You can also provide your own `ServiceReadinessCheck` implementations and register them in the `spring.factories` file.
[[features.docker-compose.lifecycle]] [[features.docker-compose.lifecycle]]