Allow to prepare the pool

Author: goetas

src/main/java/org/springframework/data/redis/connection/lettuce/DefaultLettucePoolingClientConfiguration.java

@@ -38,12 +38,26 @@ class DefaultLettucePoolingClientConfiguration implements LettucePoolingClientCo
 
 	private final LettuceClientConfiguration clientConfiguration;
 	private final GenericObjectPoolConfig poolConfig;
+	private final boolean preparePool;
 
 	DefaultLettucePoolingClientConfiguration(LettuceClientConfiguration clientConfiguration,
 			GenericObjectPoolConfig poolConfig) {
 
 		this.clientConfiguration = clientConfiguration;
 		this.poolConfig = poolConfig;
+		this.preparePool = false;
+	}
+
+	DefaultLettucePoolingClientConfiguration(LettuceClientConfiguration clientConfiguration,
+                                           GenericObjectPoolConfig poolConfig, boolean preparePool) {
+    this.clientConfiguration = clientConfiguration;
+		this.poolConfig = poolConfig;
+		this.preparePool = preparePool;
+	}
+
+	@Override
+	public boolean preparePool() {
+		return preparePool;
 	}
 
 	@Override

src/main/java/org/springframework/data/redis/connection/lettuce/LettucePoolingClientConfiguration.java

@@ -36,6 +36,7 @@
  */
 public interface LettucePoolingClientConfiguration extends LettuceClientConfiguration {
 
+	boolean preparePool();
 	/**
 	 * @return the {@link GenericObjectPoolConfig}. Never {@literal null}.
 	 */
@@ -92,6 +93,7 @@ static LettucePoolingClientConfiguration defaultConfiguration() {
 	class LettucePoolingClientConfigurationBuilder extends LettuceClientConfigurationBuilder {
 
 		GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+		boolean preparePool = false;
 
 		LettucePoolingClientConfigurationBuilder() {
 			super();
@@ -125,6 +127,12 @@ public LettucePoolingClientConfigurationBuilder commandTimeout(Duration timeout)
 			return this;
 		}
 
+		public LettucePoolingClientConfigurationBuilder preparePool(boolean preparePool) {
+
+			this.preparePool = preparePool;
+			return this;
+		}
+
 		@Override
 		public LettucePoolingClientConfigurationBuilder shutdownTimeout(Duration shutdownTimeout) {
 
@@ -173,7 +181,7 @@ public LettucePoolingClientConfigurationBuilder poolConfig(GenericObjectPoolConf
 
 		@Override
 		public LettucePoolingClientConfiguration build() {
-			return new DefaultLettucePoolingClientConfiguration(super.build(), poolConfig);
+			return new DefaultLettucePoolingClientConfiguration(super.build(), poolConfig, preparePool);
 		}
 	}
 

src/main/java/org/springframework/data/redis/connection/lettuce/LettucePoolingConnectionProvider.java

@@ -63,6 +63,7 @@ class LettucePoolingConnectionProvider implements LettuceConnectionProvider, Red
 	private static final Log log = LogFactory.getLog(LettucePoolingConnectionProvider.class);
 
 	private final LettuceConnectionProvider connectionProvider;
+	private final LettucePoolingClientConfiguration clientConfiguration;
 	private final GenericObjectPoolConfig poolConfig;
 	private final Map<StatefulConnection<?, ?>, GenericObjectPool<StatefulConnection<?, ?>>> poolRef = new ConcurrentHashMap<>(
 			32);
@@ -81,6 +82,7 @@ class LettucePoolingConnectionProvider implements LettuceConnectionProvider, Red
 		Assert.notNull(connectionProvider, "ConnectionProvider must not be null");
 		Assert.notNull(clientConfiguration, "ClientConfiguration must not be null");
 
+		this.clientConfiguration = clientConfiguration;
 		this.connectionProvider = connectionProvider;
 		this.poolConfig = clientConfiguration.getPoolConfig();
 		this.asyncPoolConfig = CommonsPool2ConfigConverter.bounded(this.poolConfig);
@@ -90,8 +92,21 @@ class LettucePoolingConnectionProvider implements LettuceConnectionProvider, Red
 	public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
 
 		GenericObjectPool<StatefulConnection<?, ?>> pool = pools.computeIfAbsent(connectionType, poolType -> {
-			return ConnectionPoolSupport.createGenericObjectPool(() -> connectionProvider.getConnection(connectionType),
-					poolConfig, false);
+
+			GenericObjectPool<StatefulConnection<?, ?>> newPool = ConnectionPoolSupport.createGenericObjectPool(() ->
+				connectionProvider.getConnection(connectionType), poolConfig, false);
+
+			if (clientConfiguration.preparePool()) {
+
+				try {
+					newPool.preparePool();
+
+				} catch (Exception ex) {
+					throw new PoolException("Could not prepare the pool", ex);
+				}
+			}
+
+			return newPool;
 		});
 
 		try {

src/test/java/org/springframework/data/redis/connection/lettuce/LettucePoolingClientConfigurationUnitTests.java

@@ -48,6 +48,7 @@ void shouldCreateEmptyConfiguration() {
 		assertThat(configuration.getPoolConfig()).isNotNull();
 		assertThat(configuration.isUseSsl()).isFalse();
 		assertThat(configuration.isVerifyPeer()).isTrue();
+		assertThat(configuration.preparePool()).isFalse();
 		assertThat(configuration.getVerifyMode().equals(SslVerifyMode.FULL));
 		assertThat(configuration.isStartTls()).isFalse();
 		assertThat(configuration.getClientOptions()).hasValueSatisfying(actual -> {
@@ -73,6 +74,7 @@ void shouldConfigureAllProperties() {
 				.disablePeerVerification() //
 				.startTls().and() //
 				.poolConfig(poolConfig) //
+				.preparePool(true)
 				.clientOptions(clientOptions) //
 				.clientResources(sharedClientResources) //
 				.commandTimeout(Duration.ofMinutes(5)) //
@@ -83,6 +85,7 @@ void shouldConfigureAllProperties() {
 		assertThat(configuration.getPoolConfig()).isEqualTo(poolConfig);
 		assertThat(configuration.isUseSsl()).isTrue();
 		assertThat(configuration.isVerifyPeer()).isFalse();
+		assertThat(configuration.preparePool()).isTrue();
 		assertThat(configuration.getVerifyMode().equals(SslVerifyMode.NONE));
 		assertThat(configuration.isStartTls()).isTrue();
 		assertThat(configuration.getClientOptions()).contains(clientOptions);

src/test/java/org/springframework/data/redis/connection/lettuce/LettucePoolingConnectionProviderUnitTests.java

@@ -20,13 +20,15 @@
 import io.lettuce.core.api.StatefulRedisConnection;
 import io.lettuce.core.api.async.RedisAsyncCommands;
 
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder;
 
 /**
  * Unit tests for {@link LettucePoolingConnectionProvider}.
@@ -70,4 +72,32 @@ void shouldDiscardTransactionOnReleaseOnActiveTransaction() {
 
 		verify(commandsMock).discard();
 	}
+
+	@Test
+	void shouldPrepareThePool() {
+
+		GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+		poolConfig.setMinIdle(5);
+		poolConfig.setMaxIdle(8);
+		poolConfig.setMaxTotal(10);
+
+		LettucePoolingClientConfiguration config = new LettucePoolingClientConfigurationBuilder()
+				.poolConfig(poolConfig)
+				.preparePool(true)
+				.build();
+
+		LettucePoolingConnectionProvider provider = new LettucePoolingConnectionProvider(connectionProviderMock, config);
+
+		provider.getConnection(StatefulRedisConnection.class);
+		verify(connectionProviderMock, times(5)).getConnection(any());
+	}
+
+	@Test
+	void shouldNotPrepareThePoolByDefault() {
+
+		LettucePoolingConnectionProvider provider = new LettucePoolingConnectionProvider(connectionProviderMock, config);
+
+		provider.getConnection(StatefulRedisConnection.class);
+		verify(connectionProviderMock, times(1)).getConnection(any());
+	}
 }