DATAREDIS-528 - Upgrade to Lettuce 4.2.2.

We now support Lettuce 4.2.2.Final. Using Lettuce requires Java 8. Original pull request: spring-projects#222.

Author: christophstrobl

pom.xml

@@ -22,7 +22,7 @@
 <beanutils>1.9.2</beanutils>
 <xstream>1.4.8</xstream>
 <pool>2.2</pool>
-<lettuce>3.4.2.Final</lettuce>
+<lettuce>4.2.2.Final</lettuce>
 <jedis>2.9.0</jedis>
 <srp>0.7</srp>
 <jredis>06052013</jredis>

src/main/java/org/springframework/data/redis/connection/ClusterCommandExecutor.java

@@ -372,6 +372,10 @@ public void destroy() throws Exception {
 if (executor instanceof DisposableBean) {
 ((DisposableBean) executor).destroy();
 }
+
+if (resourceProvider instanceof DisposableBean) {
+((DisposableBean) resourceProvider).destroy();
+}
 }
 
 /**

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

@@ -15,54 +15,44 @@
  */
 package org.springframework.data.redis.connection.lettuce;
 
-import com.lambdaworks.redis.RedisAsyncConnection;
 import com.lambdaworks.redis.RedisClient;
-import com.lambdaworks.redis.RedisConnection;
 import com.lambdaworks.redis.RedisURI;
+import com.lambdaworks.redis.api.StatefulRedisConnection;
+import com.lambdaworks.redis.api.async.RedisAsyncCommands;
 import com.lambdaworks.redis.codec.RedisCodec;
-import com.lambdaworks.redis.pubsub.RedisPubSubConnection;
+import com.lambdaworks.redis.pubsub.StatefulRedisPubSubConnection;
 
 /**
  * Extension of {@link RedisClient} that calls auth on all new connections using the supplied credentials
  * 
  * @author Jennifer Hickey
- * @author Mar Paluch
+ * @author Mark Paluch
  * @author Christoph Strobl
  * @deprecated since 1.6 - Please use {@link RedisURI#setPassword(String)}
  */
 @Deprecated
 public class AuthenticatingRedisClient extends RedisClient {
 
-private String password;
-
 public AuthenticatingRedisClient(String host, int port, String password) {
-super(host, port);
-this.password = password;
+super(null, RedisURI.builder().withHost(host).withPort(port).withPassword(password).build());
 }
 
 public AuthenticatingRedisClient(String host, String password) {
-super(host);
-this.password = password;
+super(null, RedisURI.builder().withHost(host).withPassword(password).build());
 }
 
 @Override
-public <K, V> RedisConnection<K, V> connect(RedisCodec<K, V> codec) {
-RedisConnection<K, V> conn = super.connect(codec);
-conn.auth(password);
-return conn;
+public <K, V> StatefulRedisConnection<K, V> connect(RedisCodec<K, V> codec) {
+return super.connect(codec);
 }
 
 @Override
-public <K, V> RedisAsyncConnection<K, V> connectAsync(RedisCodec<K, V> codec) {
-RedisAsyncConnection<K, V> conn = super.connectAsync(codec);
-conn.auth(password);
-return conn;
+public <K, V> RedisAsyncCommands<K, V> connectAsync(RedisCodec<K, V> codec) {
+return super.connectAsync(codec);
 }
 
 @Override
-public <K, V> RedisPubSubConnection<K, V> connectPubSub(RedisCodec<K, V> codec) {
-RedisPubSubConnection<K, V> conn = super.connectPubSub(codec);
-conn.auth(password);
-return conn;
+public <K, V> StatefulRedisPubSubConnection<K, V> connectPubSub(RedisCodec<K, V> codec) {
+return super.connectPubSub(codec);
 }
 }

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

@@ -28,9 +28,10 @@
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
-import com.lambdaworks.redis.RedisAsyncConnection;
 import com.lambdaworks.redis.RedisClient;
 import com.lambdaworks.redis.RedisURI;
+import com.lambdaworks.redis.api.StatefulConnection;
+import com.lambdaworks.redis.api.StatefulRedisConnection;
 import com.lambdaworks.redis.resource.ClientResources;
 
 /**
@@ -43,7 +44,7 @@
 public class DefaultLettucePool implements LettucePool, InitializingBean {
 
 @SuppressWarnings("rawtypes") //
-private GenericObjectPool<RedisAsyncConnection> internalPool;
+private GenericObjectPool<StatefulConnection<byte[], byte[]>> internalPool;
 private RedisClient client;
 private int dbIndex = 0;
 private GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
@@ -112,7 +113,8 @@ public void afterPropertiesSet() {
 }
 
 client.setDefaultTimeout(timeout, TimeUnit.MILLISECONDS);
-this.internalPool = new GenericObjectPool<RedisAsyncConnection>(new LettuceFactory(client, dbIndex), poolConfig);
+this.internalPool = new GenericObjectPool<StatefulConnection<byte[], byte[]>>(new LettuceFactory(client, dbIndex),
+poolConfig);
 }
 
 /**
@@ -135,23 +137,23 @@ private RedisURI createSimpleHostRedisURI() {
 }
 
 @SuppressWarnings("unchecked")
-public RedisAsyncConnection<byte[], byte[]> getResource() {
+public StatefulConnection<byte[], byte[]> getResource() {
 try {
 return internalPool.borrowObject();
 } catch (Exception e) {
 throw new PoolException("Could not get a resource from the pool", e);
 }
 }
 
-public void returnBrokenResource(final RedisAsyncConnection<byte[], byte[]> resource) {
+public void returnBrokenResource(final StatefulConnection<byte[], byte[]> resource) {
 try {
 internalPool.invalidateObject(resource);
 } catch (Exception e) {
 throw new PoolException("Could not invalidate the broken resource", e);
 }
 }
 
-public void returnResource(final RedisAsyncConnection<byte[], byte[]> resource) {
+public void returnResource(final StatefulConnection<byte[], byte[]> resource) {
 try {
 internalPool.returnObject(resource);
 } catch (Exception e) {
@@ -302,7 +304,7 @@ public void setClientResources(ClientResources clientResources) {
 }
 
 @SuppressWarnings("rawtypes")
-private static class LettuceFactory extends BasePooledObjectFactory<RedisAsyncConnection> {
+private static class LettuceFactory extends BasePooledObjectFactory<StatefulConnection<byte[], byte[]>> {
 
 private final RedisClient client;
 
@@ -315,36 +317,40 @@ public LettuceFactory(RedisClient client, int dbIndex) {
 }
 
 @Override
-public void activateObject(PooledObject<RedisAsyncConnection> pooledObject) throws Exception {
-pooledObject.getObject().select(dbIndex);
+public void activateObject(PooledObject<StatefulConnection<byte[], byte[]>> pooledObject) throws Exception {
+
+if (pooledObject.getObject() instanceof StatefulRedisConnection) {
+((StatefulRedisConnection) pooledObject.getObject()).sync().select(dbIndex);
+}
 }
 
-public void destroyObject(final PooledObject<RedisAsyncConnection> obj) throws Exception {
+public void destroyObject(final PooledObject<StatefulConnection<byte[], byte[]>> obj) throws Exception {
 try {
 obj.getObject().close();
 } catch (Exception e) {
 // Errors may happen if returning a broken resource
 }
 }
 
-public boolean validateObject(final PooledObject<RedisAsyncConnection> obj) {
+public boolean validateObject(final PooledObject<StatefulConnection<byte[], byte[]>> obj) {
 try {
-obj.getObject().ping();
+if (obj.getObject() instanceof StatefulRedisConnection) {
+((StatefulRedisConnection) obj.getObject()).sync().ping();
+}
 return true;
 } catch (Exception e) {
 return false;
 }
 }
 
 @Override
-public RedisAsyncConnection create() throws Exception {
-return client.connectAsync(LettuceConnection.CODEC);
+public StatefulConnection<byte[], byte[]> create() throws Exception {
+return client.connect(LettuceConnection.CODEC);
 }
 
 @Override
-public PooledObject<RedisAsyncConnection> wrap(RedisAsyncConnection obj) {
-return new DefaultPooledObject<RedisAsyncConnection>(obj);
+public PooledObject<StatefulConnection<byte[], byte[]>> wrap(StatefulConnection<byte[], byte[]> obj) {
+return new DefaultPooledObject<StatefulConnection<byte[], byte[]>>(obj);
 }
-
 }
 }