diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java index 706f756c2..c533a39ab 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnection.java @@ -20,9 +20,11 @@ import static com.lambdaworks.redis.protocol.CommandType.MULTI; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Properties; +import java.util.Queue; import java.util.Set; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; @@ -41,6 +43,7 @@ import org.springframework.data.redis.connection.RedisSubscribedConnectionExcept import org.springframework.data.redis.connection.ReturnType; import org.springframework.data.redis.connection.SortParameters; import org.springframework.data.redis.connection.Subscription; +import org.springframework.data.redis.connection.convert.TransactionResultConverter; import org.springframework.data.redis.connection.srp.SrpConverters; import org.springframework.util.Assert; import org.springframework.util.ObjectUtils; @@ -79,12 +82,13 @@ public class LettuceConnection implements RedisConnection { private boolean isMulti = false; private boolean isPipelined = false; private List ppline; + private Queue> txResults = new LinkedList>(); private RedisClient client; private volatile LettuceSubscription subscription; private LettucePool pool; /** flag indicating whether the connection needs to be dropped or not */ private boolean broken = false; - private boolean convertPipelineResults=true; + private boolean convertPipelineAndTxResults=true; @SuppressWarnings("rawtypes") private class LettuceResult extends FutureResult> { @@ -99,7 +103,7 @@ public class LettuceConnection implements RedisConnection { @SuppressWarnings("unchecked") @Override public Object get() { - if(convertPipelineResults && converter != null) { + if(convertPipelineAndTxResults && converter != null) { return converter.convert(resultHolder.get()); } return resultHolder.get(); @@ -114,6 +118,48 @@ public class LettuceConnection implements RedisConnection { } } + private class LettuceTxResult extends FutureResult { + public LettuceTxResult(Object resultHolder, Converter converter) { + super(resultHolder, converter); + } + + public LettuceTxResult(Object resultHolder) { + super(resultHolder); + } + + @SuppressWarnings("unchecked") + @Override + public Object get() { + if(convertPipelineAndTxResults && converter != null) { + return converter.convert(resultHolder); + } + return resultHolder; + } + } + + private class LettuceTxStatusResult extends LettuceTxResult { + public LettuceTxStatusResult(Object resultHolder) { + super(resultHolder); + setStatus(true); + } + } + + private class LettuceTransactionResultConverter extends TransactionResultConverter { + public LettuceTransactionResultConverter(Queue> txResults, + Converter exceptionConverter) { + super(txResults, exceptionConverter); + } + + @Override + public List convert(List execResults) { + // Lettuce Empty list means null (watched variable modified) + if(execResults.isEmpty()) { + return null; + } + return super.convert(execResults); + } + } + /** * Instantiates a new lettuce connection. * @@ -213,8 +259,10 @@ public class LettuceConnection implements RedisConnection { if (isPipelined()) { pipeline(new LettuceResult(getAsyncConnection().dispatch(cmd, new ByteArrayOutput(CODEC), cmdArg))); return null; - } - else { + } else if(isQueueing()) { + transaction(new LettuceResult(getAsyncConnection().dispatch(cmd, new ByteArrayOutput(CODEC), cmdArg))); + return null; + } else { return await(getAsyncConnection().dispatch(cmd, new ByteArrayOutput(CODEC), cmdArg)); } } catch (RedisException ex) { @@ -296,8 +344,15 @@ public class LettuceConnection implements RedisConnection { } results.add(err); } - else if(!convertPipelineResults || !(result.isStatus())) { - results.add(result.get()); + else if(!convertPipelineAndTxResults || !(result.isStatus())) { + try { + results.add(result.get()); + }catch(DataAccessException e) { + if (problem == null) { + problem = e; + } + results.add(e); + } } } } @@ -326,6 +381,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sort(key, args))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sort(key, args))); + return null; + } return getConnection().sort(key, args); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -341,6 +400,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sortStore(key, args, sortKey))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sortStore(key, args, sortKey))); + return null; + } return getConnection().sortStore(key, args, sortKey); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -353,6 +416,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().dbsize())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().dbsize())); + return null; + } return getConnection().dbsize(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -367,6 +434,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().flushdb())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().flushdb())); + return; + } getConnection().flushdb(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -380,6 +451,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().flushall())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().flushall())); + return; + } getConnection().flushall(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -393,6 +468,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().bgsave())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().bgsave())); + return; + } getConnection().bgsave(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -406,6 +485,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().bgrewriteaof())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().bgrewriteaof())); + return; + } getConnection().bgrewriteaof(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -419,6 +502,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().save())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().save())); + return; + } getConnection().save(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -432,6 +519,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().configGet(param))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().configGet(param))); + return null; + } return getConnection().configGet(param); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -445,6 +536,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().info(), LettuceConverters.stringToProps())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().info(), LettuceConverters.stringToProps())); + return null; + } return LettuceConverters.toProperties(getConnection().info()); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -458,6 +553,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().info(section), LettuceConverters.stringToProps())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().info(section), LettuceConverters.stringToProps())); + return null; + } return LettuceConverters.toProperties(getConnection().info(section)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -471,6 +570,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lastsave(), LettuceConverters.dateToLong())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lastsave(), LettuceConverters.dateToLong())); + return null; + } return LettuceConverters.toLong(getConnection().lastsave()); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -484,6 +587,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().configSet(param, value))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().configSet(param, value))); + return; + } getConnection().configSet(param, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -498,6 +605,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().configResetstat())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().configResetstat())); + return; + } getConnection().configResetstat(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -524,6 +635,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().echo(message))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().echo(message))); + return null; + } return getConnection().echo(message); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -537,6 +652,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().ping())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().ping())); + return null; + } return getConnection().ping(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -550,6 +669,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().del(keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().del(keys))); + return null; + } return getConnection().del(keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -566,19 +689,28 @@ public class LettuceConnection implements RedisConnection { getDedicatedConnection().discard(); } catch (Exception ex) { throw convertLettuceAccessException(ex); + } finally { + txResults.clear(); } } + @SuppressWarnings({ "unchecked", "rawtypes" }) public List exec() { isMulti = false; try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncDedicatedConnection().exec(), LettuceConverters.execResultsConverter())); + pipeline(new LettuceResult(getAsyncDedicatedConnection().exec(), + new LettuceTransactionResultConverter(new LinkedList>(txResults), + LettuceConverters.exceptionConverter()))); return null; } - return LettuceConverters.toExecResults(getDedicatedConnection().exec()); + List results = getDedicatedConnection().exec(); + return convertPipelineAndTxResults ? new LettuceTransactionResultConverter(txResults, + LettuceConverters.exceptionConverter()).convert(results) : results; } catch (Exception ex) { throw convertLettuceAccessException(ex); + } finally { + txResults.clear(); } } @@ -589,6 +721,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().exists(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().exists(key))); + return null; + } return getConnection().exists(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -602,6 +738,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().expire(key, seconds))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().expire(key, seconds))); + return null; + } return getConnection().expire(key, seconds); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -615,6 +755,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().expireat(key, unixTime))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().expireat(key, unixTime))); + return null; + } return getConnection().expireat(key, unixTime); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -627,6 +771,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().pexpire(key, millis))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().pexpire(key, millis))); + return null; + } return getConnection().pexpire(key, millis); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -639,6 +787,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().pexpireat(key, unixTimeInMillis))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().pexpireat(key, unixTimeInMillis))); + return null; + } return getConnection().pexpireat(key, unixTimeInMillis); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -651,6 +803,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().pttl(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().pttl(key))); + return null; + } return getConnection().pttl(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -663,6 +819,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().dump(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().dump(key))); + return null; + } return getConnection().dump(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -675,6 +835,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().restore(key, ttlInMillis, serializedValue))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().restore(key, ttlInMillis, serializedValue))); + return; + } getConnection().restore(key, ttlInMillis, serializedValue); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -687,6 +851,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().keys(pattern), LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().keys(pattern), LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().keys(pattern)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -716,6 +884,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().persist(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().persist(key))); + return null; + } return getConnection().persist(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -729,6 +901,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().move(key, dbIndex))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().move(key, dbIndex))); + return null; + } return getConnection().move(key, dbIndex); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -742,6 +918,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().randomkey())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().randomkey())); + return null; + } return getConnection().randomkey(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -754,6 +934,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().rename(oldName, newName))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().rename(oldName, newName))); + return; + } getConnection().rename(oldName, newName); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -767,6 +951,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().renamenx(oldName, newName))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().renamenx(oldName, newName))); + return null; + } return (getConnection().renamenx(oldName, newName)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -783,6 +971,10 @@ public class LettuceConnection implements RedisConnection { throw new UnsupportedOperationException("Lettuce blocks for #select"); } try { + if(isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().select(dbIndex))); + return; + } getConnection().select(dbIndex); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -796,6 +988,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().ttl(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().ttl(key))); + return null; + } return getConnection().ttl(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -808,6 +1004,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().type(key), LettuceConverters.stringToDataType())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().type(key), LettuceConverters.stringToDataType())); + return null; + } return LettuceConverters.toDataType(getConnection().type(key)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -820,6 +1020,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncDedicatedConnection().unwatch())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getDedicatedConnection().unwatch())); + return; + } getDedicatedConnection().unwatch(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -851,7 +1055,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().get(key))); return null; } - + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().get(key))); + return null; + } return getConnection().get(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -864,6 +1071,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().set(key, value))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().set(key, value))); + return; + } getConnection().set(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -878,6 +1089,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().getset(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().getset(key, value))); + return null; + } return getConnection().getset(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -890,6 +1105,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().append(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().append(key, value))); + return null; + } return getConnection().append(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -902,6 +1121,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().mget(keys))); return null; } + if(isQueueing()) { + transaction(new LettuceTxResult(getConnection().mget(keys))); + return null; + } return getConnection().mget(keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -915,6 +1138,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().mset(tuples))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().mset(tuples))); + return; + } getConnection().mset(tuples); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -928,6 +1155,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().msetnx(tuples))); return null; } + if(isQueueing()) { + transaction(new LettuceTxResult(getConnection().msetnx(tuples))); + return null; + } return getConnection().msetnx(tuples); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -941,6 +1172,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().setex(key, time, value))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().setex(key, time, value))); + return; + } getConnection().setex(key, time, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -954,6 +1189,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().setnx(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().setnx(key, value))); + return null; + } return getConnection().setnx(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -967,6 +1206,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().getrange(key, start, end))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().getrange(key, start, end))); + return null; + } return getConnection().getrange(key, start, end); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -979,6 +1222,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().decr(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().decr(key))); + return null; + } return getConnection().decr(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -991,6 +1238,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().decrby(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().decrby(key, value))); + return null; + } return getConnection().decrby(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1003,6 +1254,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().incr(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().incr(key))); + return null; + } return getConnection().incr(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1015,6 +1270,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().incrby(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().incrby(key, value))); + return null; + } return getConnection().incrby(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1027,6 +1286,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().incrbyfloat(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().incrbyfloat(key, value))); + return null; + } return getConnection().incrbyfloat(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1039,6 +1302,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().getbit(key, offset), LettuceConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().getbit(key, offset), LettuceConverters.longToBoolean())); + return null; + } return LettuceConverters.toBoolean(getConnection().getbit(key, offset)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1052,6 +1319,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().setbit(key, offset, LettuceConverters.toInt(value)))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().setbit(key, offset, LettuceConverters.toInt(value)))); + return; + } getConnection().setbit(key, offset, LettuceConverters.toInt(value)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1065,6 +1336,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().setrange(key, start, value))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().setrange(key, start, value))); + return; + } getConnection().setrange(key, start, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1078,6 +1353,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().strlen(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().strlen(key))); + return null; + } return getConnection().strlen(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1091,6 +1370,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().bitcount(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().bitcount(key))); + return null; + } return getConnection().bitcount(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1104,6 +1387,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().bitcount(key, begin, end))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().bitcount(key, begin, end))); + return null; + } return getConnection().bitcount(key, begin, end); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1117,6 +1404,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(asyncBitOp(op, destination, keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(syncBitOp(op, destination, keys))); + return null; + } return syncBitOp(op, destination, keys); } catch (UnsupportedOperationException ex) { throw ex; @@ -1136,6 +1427,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lpush(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lpush(key, value))); + return null; + } return getConnection().lpush(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1148,6 +1443,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().rpush(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().rpush(key, value))); + return null; + } return getConnection().rpush(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1157,7 +1456,13 @@ public class LettuceConnection implements RedisConnection { public List bLPop(int timeout, byte[]... keys) { try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncDedicatedConnection().blpop(timeout, keys), LettuceConverters.keyValueToBytesList())); + pipeline(new LettuceResult(getAsyncDedicatedConnection().blpop(timeout, keys), + LettuceConverters.keyValueToBytesList())); + return null; + } + if (isQueueing()) { + transaction(new LettuceTxResult(getDedicatedConnection().blpop(timeout, keys), + LettuceConverters.keyValueToBytesList())); return null; } return LettuceConverters.toBytesList(getDedicatedConnection().blpop(timeout, keys)); @@ -1169,7 +1474,13 @@ public class LettuceConnection implements RedisConnection { public List bRPop(int timeout, byte[]... keys) { try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncDedicatedConnection().brpop(timeout, keys), LettuceConverters.keyValueToBytesList())); + pipeline(new LettuceResult(getAsyncDedicatedConnection().brpop(timeout, keys), + LettuceConverters.keyValueToBytesList())); + return null; + } + if (isQueueing()) { + transaction(new LettuceTxResult(getDedicatedConnection().brpop(timeout, keys), + LettuceConverters.keyValueToBytesList())); return null; } return LettuceConverters.toBytesList(getDedicatedConnection().brpop(timeout, keys)); @@ -1184,6 +1495,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lindex(key, index))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lindex(key, index))); + return null; + } return getConnection().lindex(key, index); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1193,7 +1508,13 @@ public class LettuceConnection implements RedisConnection { public Long lInsert(byte[] key, Position where, byte[] pivot, byte[] value) { try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncConnection().linsert(key, LettuceConverters.toBoolean(where), pivot, value))); + pipeline(new LettuceResult(getAsyncConnection().linsert(key, + LettuceConverters.toBoolean(where), pivot, value))); + return null; + } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().linsert(key, + LettuceConverters.toBoolean(where), pivot, value))); return null; } return getConnection().linsert(key, LettuceConverters.toBoolean(where), pivot, value); @@ -1208,6 +1529,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().llen(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().llen(key))); + return null; + } return getConnection().llen(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1220,6 +1545,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lpop(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lpop(key))); + return null; + } return getConnection().lpop(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1232,6 +1561,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lrange(key, start, end))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lrange(key, start, end))); + return null; + } return getConnection().lrange(key, start, end); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1245,6 +1578,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lrem(key, count, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lrem(key, count, value))); + return null; + } return getConnection().lrem(key, count, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1257,6 +1594,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().lset(key, index, value))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().lset(key, index, value))); + return; + } getConnection().lset(key, index, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1270,6 +1611,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().ltrim(key, start, end))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().ltrim(key, start, end))); + return; + } getConnection().ltrim(key, start, end); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1283,6 +1628,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().rpop(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().rpop(key))); + return null; + } return getConnection().rpop(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1295,6 +1644,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().rpoplpush(srcKey, dstKey))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().rpoplpush(srcKey, dstKey))); + return null; + } return getConnection().rpoplpush(srcKey, dstKey); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1307,6 +1660,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncDedicatedConnection().brpoplpush(timeout, srcKey, dstKey))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getDedicatedConnection().brpoplpush(timeout, srcKey, dstKey))); + return null; + } return getDedicatedConnection().brpoplpush(timeout, srcKey, dstKey); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1319,6 +1676,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().lpushx(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().lpushx(key, value))); + return null; + } return getConnection().lpushx(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1331,6 +1692,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().rpushx(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().rpushx(key, value))); + return null; + } return getConnection().rpushx(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1348,6 +1713,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sadd(key, value), SrpConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sadd(key, value), SrpConverters.longToBoolean())); + return null; + } return SrpConverters.toBoolean(getConnection().sadd(key, value)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1361,6 +1730,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().scard(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().scard(key))); + return null; + } return getConnection().scard(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1373,6 +1746,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sdiff(keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sdiff(keys))); + return null; + } return getConnection().sdiff(keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1386,6 +1763,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sdiffstore(destKey, keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sdiffstore(destKey, keys))); + return null; + } return getConnection().sdiffstore(destKey, keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1398,6 +1779,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sinter(keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sinter(keys))); + return null; + } return getConnection().sinter(keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1411,6 +1796,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sinterstore(destKey, keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sinterstore(destKey, keys))); + return null; + } return getConnection().sinterstore(destKey, keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1423,6 +1812,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sismember(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sismember(key, value))); + return null; + } return getConnection().sismember(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1436,6 +1829,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().smembers(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().smembers(key))); + return null; + } return getConnection().smembers(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1449,6 +1846,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().smove(srcKey, destKey, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().smove(srcKey, destKey, value))); + return null; + } return getConnection().smove(srcKey, destKey, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1462,6 +1863,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().spop(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().spop(key))); + return null; + } return getConnection().spop(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1474,6 +1879,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().srandmember(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().srandmember(key))); + return null; + } return getConnection().srandmember(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1489,6 +1898,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().srandmember(key, count), LettuceConverters.bytesSetToBytesList())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().srandmember(key, count), LettuceConverters.bytesSetToBytesList())); + return null; + } return LettuceConverters.toBytesList(getConnection().srandmember(key, count)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1501,6 +1914,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().srem(key, value), LettuceConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().srem(key, value), LettuceConverters.longToBoolean())); + return null; + } return LettuceConverters.toBoolean(getConnection().srem(key, value)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1513,6 +1930,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sunion(keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sunion(keys))); + return null; + } return getConnection().sunion(keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1526,6 +1947,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().sunionstore(destKey, keys))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().sunionstore(destKey, keys))); + return null; + } return getConnection().sunionstore(destKey, keys); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1543,6 +1968,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zadd(key, score, value), LettuceConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zadd(key, score, value), LettuceConverters.longToBoolean())); + return null; + } return LettuceConverters.toBoolean(getConnection().zadd(key, score, value)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1555,6 +1984,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zcard(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zcard(key))); + return null; + } return getConnection().zcard(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1567,6 +2000,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zcount(key, min, max))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zcount(key, min, max))); + return null; + } return getConnection().zcount(key, min, max); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1579,6 +2016,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zincrby(key, increment, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zincrby(key, increment, value))); + return null; + } return getConnection().zincrby(key, increment, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1593,6 +2034,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zinterstore(destKey, storeArgs, sets))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zinterstore(destKey, storeArgs, sets))); + return null; + } return getConnection().zinterstore(destKey, storeArgs, sets); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1606,6 +2051,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zinterstore(destKey, sets))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zinterstore(destKey, sets))); + return null; + } return getConnection().zinterstore(destKey, sets); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1615,7 +2064,13 @@ public class LettuceConnection implements RedisConnection { public Set zRange(byte[] key, long start, long end) { try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncConnection().zrange(key, start, end), LettuceConverters.bytesListToBytesSet())); + pipeline(new LettuceResult(getAsyncConnection().zrange(key, start, end), + LettuceConverters.bytesListToBytesSet())); + return null; + } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrange(key, start, end), + LettuceConverters.bytesListToBytesSet())); return null; } return LettuceConverters.toBytesSet(getConnection().zrange(key, start, end)); @@ -1628,7 +2083,13 @@ public class LettuceConnection implements RedisConnection { public Set zRangeWithScores(byte[] key, long start, long end) { try { if (isPipelined()) { - pipeline(new LettuceResult(getAsyncConnection().zrangeWithScores(key, start, end), LettuceConverters.scoredValuesToTupleSet())); + pipeline(new LettuceResult(getAsyncConnection().zrangeWithScores(key, start, end), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrangeWithScores(key, start, end), + LettuceConverters.scoredValuesToTupleSet())); return null; } return LettuceConverters.toTupleSet(getConnection().zrangeWithScores(key, start, end)); @@ -1645,6 +2106,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrangebyscore(key, min, max), + LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().zrangebyscore(key, min, max)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1659,6 +2125,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.scoredValuesToTupleSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrangebyscoreWithScores(key, min, max), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } return LettuceConverters.toTupleSet(getConnection().zrangebyscoreWithScores(key, min, max)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1673,6 +2144,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.scoredValuesToTupleSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrangeWithScores(key, start, end), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } return LettuceConverters.toTupleSet(getConnection().zrevrangeWithScores(key, start, end)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1687,6 +2163,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrangebyscore(key, min, max, offset, count), + LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().zrangebyscore(key, min, max, offset, count)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1701,6 +2182,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.scoredValuesToTupleSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrangebyscoreWithScores(key, min, max, offset, count), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } return LettuceConverters.toTupleSet(getConnection().zrangebyscoreWithScores(key, min, max, offset, count)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1715,6 +2201,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrangebyscore(key, max, min, offset, count), + LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().zrevrangebyscore(key, max, min, offset, count)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1729,6 +2220,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrangebyscore(key, max, min), + LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().zrevrangebyscore(key, max, min)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1743,6 +2239,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.scoredValuesToTupleSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrangebyscoreWithScores(key, max, min, offset, count), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } return LettuceConverters.toTupleSet(getConnection().zrevrangebyscoreWithScores(key, max, min, offset, count)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1757,6 +2258,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.scoredValuesToTupleSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrangebyscoreWithScores(key, max, min), + LettuceConverters.scoredValuesToTupleSet())); + return null; + } return LettuceConverters.toTupleSet(getConnection().zrevrangebyscoreWithScores(key, max, min)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1770,6 +2276,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zrank(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrank(key, value))); + return null; + } return getConnection().zrank(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1782,6 +2292,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zrem(key, value), LettuceConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrem(key, value), LettuceConverters.longToBoolean())); + return null; + } return LettuceConverters.toBoolean(getConnection().zrem(key, value)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1795,6 +2309,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zremrangebyrank(key, start, end))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zremrangebyrank(key, start, end))); + return null; + } return getConnection().zremrangebyrank(key, start, end); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1807,6 +2325,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zremrangebyscore(key, min, max))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zremrangebyscore(key, min, max))); + return null; + } return getConnection().zremrangebyscore(key, min, max); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1820,6 +2342,11 @@ public class LettuceConnection implements RedisConnection { LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrange(key, start, end), + LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().zrevrange(key, start, end)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1833,6 +2360,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zrevrank(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zrevrank(key, value))); + return null; + } return getConnection().zrevrank(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1845,6 +2376,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zscore(key, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zscore(key, value))); + return null; + } return getConnection().zscore(key, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1860,6 +2395,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zunionstore(destKey, storeArgs, sets))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zunionstore(destKey, storeArgs, sets))); + return null; + } return getConnection().zunionstore(destKey, storeArgs, sets); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1873,6 +2412,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().zunionstore(destKey, sets))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().zunionstore(destKey, sets))); + return null; + } return getConnection().zunionstore(destKey, sets); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1889,6 +2432,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hset(key, field, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hset(key, field, value))); + return null; + } return getConnection().hset(key, field, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1902,6 +2449,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hsetnx(key, field, value))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hsetnx(key, field, value))); + return null; + } return getConnection().hsetnx(key, field, value); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1915,6 +2466,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hdel(key, field), LettuceConverters.longToBoolean())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hdel(key, field), LettuceConverters.longToBoolean())); + return null; + } return LettuceConverters.toBoolean(getConnection().hdel(key, field)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1928,6 +2483,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hexists(key, field))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hexists(key, field))); + return null; + } return getConnection().hexists(key, field); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1941,6 +2500,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hget(key, field))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hget(key, field))); + return null; + } return getConnection().hget(key, field); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1953,6 +2516,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hgetall(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hgetall(key))); + return null; + } return getConnection().hgetall(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1966,6 +2533,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hincrby(key, field, delta))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hincrby(key, field, delta))); + return null; + } return getConnection().hincrby(key, field, delta); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1978,6 +2549,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hincrbyfloat(key, field, delta))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hincrbyfloat(key, field, delta))); + return null; + } return getConnection().hincrbyfloat(key, field, delta); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -1990,6 +2565,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hkeys(key), LettuceConverters.bytesListToBytesSet())); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hkeys(key), LettuceConverters.bytesListToBytesSet())); + return null; + } return LettuceConverters.toBytesSet(getConnection().hkeys(key)); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2003,6 +2582,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hlen(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hlen(key))); + return null; + } return getConnection().hlen(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2015,6 +2598,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hmget(key, fields))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hmget(key, fields))); + return null; + } return getConnection().hmget(key, fields); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2028,6 +2615,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().hmset(key, tuple))); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().hmset(key, tuple))); + return; + } getConnection().hmset(key, tuple); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2041,6 +2632,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().hvals(key))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().hvals(key))); + return null; + } return getConnection().hvals(key); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2058,6 +2653,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().scriptFlush())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().scriptFlush())); + return; + } getConnection().scriptFlush(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2073,6 +2672,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceStatusResult(getAsyncConnection().scriptKill())); return; } + if (isQueueing()) { + transaction(new LettuceTxStatusResult(getConnection().scriptKill())); + return; + } getConnection().scriptKill(); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2085,6 +2688,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().scriptLoad(script))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().scriptLoad(script))); + return null; + } return getConnection().scriptLoad(script); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2097,6 +2704,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().scriptExists(scriptSha1))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().scriptExists(scriptSha1))); + return null; + } return getConnection().scriptExists(scriptSha1); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2112,6 +2723,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().eval(script, LettuceConverters.toScriptOutputType(returnType), keys, args))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().eval(script, LettuceConverters.toScriptOutputType(returnType), keys, args))); + return null; + } return getConnection().eval(script, LettuceConverters.toScriptOutputType(returnType), keys, args); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2128,6 +2743,11 @@ public class LettuceConnection implements RedisConnection { keys, args))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().evalsha(scriptSha1, LettuceConverters.toScriptOutputType(returnType), + keys, args))); + return null; + } return getConnection().evalsha(scriptSha1, LettuceConverters.toScriptOutputType(returnType), keys, args); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2144,6 +2764,10 @@ public class LettuceConnection implements RedisConnection { pipeline(new LettuceResult(getAsyncConnection().publish(channel, message))); return null; } + if (isQueueing()) { + transaction(new LettuceTxResult(getConnection().publish(channel, message))); + return null; + } return getConnection().publish(channel, message); } catch (Exception ex) { throw convertLettuceAccessException(ex); @@ -2194,14 +2818,14 @@ public class LettuceConnection implements RedisConnection { } /** - * Specifies if pipelined results should be converted to the expected data - * type. If false, results of {@link #closePipeline()} will be of the + * Specifies if pipelined and transaction results should be converted to the expected data + * type. If false, results of {@link #closePipeline()} and {@link #exec()} will be of the * type returned by the Lettuce driver * - * @param convertPipelineResults Whether or not to convert pipeline results + * @param convertPipelineAndTxResults Whether or not to convert pipeline and tx results */ - public void setConvertPipelineResults(boolean convertPipelineResults) { - this.convertPipelineResults = convertPipelineResults; + public void setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults) { + this.convertPipelineAndTxResults = convertPipelineAndTxResults; } private void checkSubscription() { @@ -2218,12 +2842,17 @@ public class LettuceConnection implements RedisConnection { } private void pipeline(LettuceResult result) { - if(!isQueueing()) { - // Don't add individual tx op results to pipeline + if(isQueueing()) { + transaction(result); + }else { ppline.add(result); } } + private void transaction(FutureResult result) { + txResults.add(result); + } + private RedisAsyncConnection getAsyncConnection() { if (isQueueing()) { return getAsyncDedicatedConnection(); diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java index afd9e179c..096c11e05 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java @@ -71,7 +71,7 @@ public class LettuceConnectionFactory implements InitializingBean, DisposableBea /** Synchronization monitor for the shared Connection */ private final Object connectionMonitor = new Object(); private String password; - private boolean convertPipelineResults = true; + private boolean convertPipelineAndTxResults = true; /** * Constructs a new LettuceConnectionFactory instance with @@ -108,7 +108,7 @@ public class LettuceConnectionFactory implements InitializingBean, DisposableBea public RedisConnection getConnection() { LettuceConnection connection = new LettuceConnection(getSharedConnection(), timeout, client, pool); - connection.setConvertPipelineResults(convertPipelineResults); + connection.setConvertPipelineAndTxResults(convertPipelineAndTxResults); return connection; } @@ -302,24 +302,24 @@ public class LettuceConnectionFactory implements InitializingBean, DisposableBea /** * Specifies if pipelined results should be converted to the expected data - * type. If false, results of {@link #closePipeline()} will be of the - * type returned by the Jedis driver + * type. If false, results of {@link LettuceConnection#closePipeline()} and {LettuceConnection#exec()} + * will be of the type returned by the Lettuce driver * - * @return Whether or not to convert pipeline results + * @return Whether or not to convert pipeline and tx results */ - public boolean getConvertPipelineResults() { - return convertPipelineResults; + public boolean getConvertPipelineAndTxResults() { + return convertPipelineAndTxResults; } /** - * Specifies if pipelined results should be converted to the expected data - * type. If false, results of {@link #closePipeline()} will be of the - * type returned by the Jedis driver + * Specifies if pipelined and transaction results should be converted to the expected data + * type. If false, results of {@link LettuceConnection#closePipeline()} and {LettuceConnection#exec()} + * will be of the type returned by the Lettuce driver * - * @param convertPipelineResults Whether or not to convert pipeline results + * @param convertPipelineAndTxResults Whether or not to convert pipeline and tx results */ - public void setConvertPipelineResults(boolean convertPipelineResults) { - this.convertPipelineResults = convertPipelineResults; + public void setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults) { + this.convertPipelineAndTxResults = convertPipelineAndTxResults; } protected RedisAsyncConnection getSharedConnection() { diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java index a854e8f5f..fd8402280 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java @@ -20,26 +20,19 @@ import java.util.Date; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; -import java.util.concurrent.TimeoutException; -import org.jboss.netty.channel.ChannelException; import org.springframework.core.convert.converter.Converter; import org.springframework.dao.DataAccessException; -import org.springframework.dao.QueryTimeoutException; -import org.springframework.data.redis.RedisConnectionFailureException; -import org.springframework.data.redis.RedisSystemException; import org.springframework.data.redis.connection.DefaultTuple; -import org.springframework.data.redis.connection.ReturnType; import org.springframework.data.redis.connection.RedisListCommands.Position; import org.springframework.data.redis.connection.RedisZSetCommands.Tuple; +import org.springframework.data.redis.connection.ReturnType; import org.springframework.data.redis.connection.SortParameters; import org.springframework.data.redis.connection.SortParameters.Order; import org.springframework.data.redis.connection.convert.Converters; import org.springframework.util.Assert; import com.lambdaworks.redis.KeyValue; -import com.lambdaworks.redis.RedisCommandInterruptedException; -import com.lambdaworks.redis.RedisException; import com.lambdaworks.redis.ScoredValue; import com.lambdaworks.redis.ScriptOutputType; import com.lambdaworks.redis.SortArgs; @@ -59,7 +52,7 @@ abstract public class LettuceConverters extends Converters { private static final Converter, List> KEY_VALUE_TO_BYTES_LIST; private static final Converter>, Set> SCORED_VALUES_TO_TUPLE_SET; private static final Converter, Tuple> SCORED_VALUE_TO_TUPLE; - private static final Converter, List> EXEC_RESULTS_CONVERTER; + private static final Converter EXCEPTION_CONVERTER = new LettuceExceptionConverter(); static { DATE_TO_LONG = new Converter() { @@ -108,16 +101,6 @@ abstract public class LettuceConverters extends Converters { } }; - - EXEC_RESULTS_CONVERTER = new Converter, List>() { - public List convert(List source) { - // Lettuce Empty list means null (watched variable modified) - if(source.isEmpty()) { - return null; - } - return source; - } - }; } public static Converter dateToLong() { @@ -144,8 +127,8 @@ abstract public class LettuceConverters extends Converters { return SCORED_VALUE_TO_TUPLE; } - public static Converter, List> execResultsConverter() { - return EXEC_RESULTS_CONVERTER; + public static Converter exceptionConverter() { + return EXCEPTION_CONVERTER; } public static Long toLong(Date source) { @@ -173,19 +156,7 @@ abstract public class LettuceConverters extends Converters { } public static DataAccessException toDataAccessException(Exception ex) { - if (ex instanceof RedisCommandInterruptedException) { - return new RedisSystemException("Redis command interrupted", ex); - } - if (ex instanceof RedisException) { - return new RedisSystemException("Redis exception", ex); - } - if (ex instanceof ChannelException) { - return new RedisConnectionFailureException("Redis connection failed", ex); - } - if (ex instanceof TimeoutException) { - return new QueryTimeoutException("Redis command timed out", ex); - } - return new RedisSystemException("Unknown Lettuce exception", ex); + return EXCEPTION_CONVERTER.convert(ex); } public static ScriptOutputType toScriptOutputType(ReturnType returnType) { @@ -245,8 +216,4 @@ abstract public class LettuceConverters extends Converters { } return args; } - - public static List toExecResults(List source) { - return EXEC_RESULTS_CONVERTER.convert(source); - } } diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceExceptionConverter.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceExceptionConverter.java new file mode 100644 index 000000000..30f6ab5b4 --- /dev/null +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceExceptionConverter.java @@ -0,0 +1,56 @@ +/* + * Copyright 2013 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 + * + * http://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.data.redis.connection.lettuce; + +import java.util.concurrent.TimeoutException; + +import org.jboss.netty.channel.ChannelException; +import org.springframework.core.convert.converter.Converter; +import org.springframework.dao.DataAccessException; +import org.springframework.dao.QueryTimeoutException; +import org.springframework.data.redis.RedisConnectionFailureException; +import org.springframework.data.redis.RedisSystemException; + +import com.lambdaworks.redis.RedisCommandInterruptedException; +import com.lambdaworks.redis.RedisException; + +/** + * Converts Lettuce Exceptions to {@link DataAccessException}s + * + * @author Jennifer Hickey + * + */ +public class LettuceExceptionConverter implements Converter { + + public DataAccessException convert(Exception ex) { + if (ex instanceof DataAccessException) { + return (DataAccessException) ex; + } + if (ex instanceof RedisCommandInterruptedException) { + return new RedisSystemException("Redis command interrupted", ex); + } + if (ex instanceof RedisException) { + return new RedisSystemException("Redis exception", ex); + } + if (ex instanceof ChannelException) { + return new RedisConnectionFailureException("Redis connection failed", ex); + } + if (ex instanceof TimeoutException) { + return new QueryTimeoutException("Redis command timed out", ex); + } + return new RedisSystemException("Unknown Lettuce exception", ex); + } +} diff --git a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java index d659d2d85..950fbed4c 100644 --- a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java @@ -1,41 +1,17 @@ package org.springframework.data.redis.connection; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.LinkedHashSet; import java.util.List; -import java.util.Map; -import java.util.Set; -import org.junit.Before; import org.junit.Ignore; import org.junit.Test; -import org.springframework.dao.DataAccessException; -import org.springframework.data.redis.RedisSystemException; -import org.springframework.data.redis.connection.convert.Converters; -import org.springframework.data.redis.serializer.SerializationUtils; import org.springframework.test.annotation.IfProfileValue; abstract public class AbstractConnectionTransactionIntegrationTests extends AbstractConnectionIntegrationTests { - protected boolean convert = true; - - protected boolean convertLongToBoolean = true; - - protected boolean convertStringToProps = false; - - @Before - public void setUp() { - super.setUp(); - ((DefaultStringRedisConnection)connection).setDeserializePipelineAndTxResults(false); - } - @Ignore public void testMultiDiscard() { } @@ -116,325 +92,11 @@ abstract public class AbstractConnectionTransactionIntegrationTests extends public void testHashNullValue() throws Exception { } - @Test(expected=UnsupportedOperationException.class) + @Test(expected = UnsupportedOperationException.class) public void testWatchWhileInTx() { connection.watch("foo".getBytes()); } - // Type conversion overrides - - @Test - public void testExecute() { - connection.set("foo", "bar"); - actual.add(connection.execute("GET", "foo")); - assertEquals("bar", getResults().get(0)); - } - - @Test - public void testExecuteNoArgs() { - actual.add(connection.execute("PING")); - assertEquals("PONG", getResults().get(0)); - } - - @Test - public void testSort() { - convertLongToBoolean = false; - super.testSort(); - } - - @Test - public void testSortStore() { - convertLongToBoolean = false; - super.testSortStore(); - } - - @Test - public void testSortNullParams() { - convertLongToBoolean = false; - super.testSortNullParams(); - } - - @Test - public void testDbSize() { - convertLongToBoolean = false; - super.testDbSize(); - } - - @Test - public void testFlushDb() { - convertLongToBoolean = false; - super.testFlushDb(); - } - - @Test - public void testDel() { - convertLongToBoolean = false; - super.testDel(); - } - - @Test - public void testIncDecrByLong() { - convertLongToBoolean = false; - super.testIncrDecrByLong(); - } - - @Test - public void testDecrByIncrBy() { - convertLongToBoolean = false; - super.testDecrByIncrBy(); - } - - @Test - public void testIncrDecr() { - convertLongToBoolean = false; - super.testIncDecr(); - } - - @Test - public void testLInsert() { - convertLongToBoolean = false; - super.testLInsert(); - } - - @Test - public void testLRem() { - convertLongToBoolean = false; - super.testLRem(); - } - - @Test - public void testLPop() { - convertLongToBoolean = false; - super.testLPop(); - } - - @Test - public void testLLen() { - convertLongToBoolean = false; - super.testLLen(); - } - - @Test - public void testLSet() { - convertLongToBoolean = false; - super.testLSet(); - } - - @Test - public void testLTrim() { - convertLongToBoolean = false; - super.testLTrim(); - } - - @Test - public void testRPop() { - convertLongToBoolean = false; - super.testRPop(); - } - - @Test - public void testRPopLPush() { - convertLongToBoolean = false; - super.testRPopLPush(); - } - - @Test - public void testLPushX() { - convertLongToBoolean = false; - super.testLPushX(); - } - - @Test - public void testRPushX() { - convertLongToBoolean = false; - super.testRPushX(); - } - - @Test - public void testLIndex() { - convertLongToBoolean = false; - super.testLIndex(); - } - - @Test - public void testLPush() throws Exception { - convertLongToBoolean = false; - super.testLPush(); - } - - @Test - public void testSDiffStore() { - convertLongToBoolean = false; - actual.add(connection.sAdd("myset", "foo")); - actual.add(connection.sAdd("myset", "bar")); - actual.add(connection.sAdd("otherset", "bar")); - actual.add(connection.sDiffStore("thirdset", "myset", "otherset")); - actual.add(connection.sMembers("thirdset")); - verifyResults(Arrays.asList(new Object[] { 1l, 1l, 1l, 1l, - new HashSet(Collections.singletonList("foo")) })); - } - - @Test - public void testSInterStore() { - convertLongToBoolean = false; - actual.add(connection.sAdd("myset", "foo")); - actual.add(connection.sAdd("myset", "bar")); - actual.add(connection.sAdd("otherset", "bar")); - actual.add(connection.sInterStore("thirdset", "myset", "otherset")); - actual.add(connection.sMembers("thirdset")); - verifyResults(Arrays.asList(new Object[] { 1l, 1l, 1l, 1l, - new HashSet(Collections.singletonList("bar")) })); - } - - @Test - public void testZRank() { - convertLongToBoolean = false; - actual.add(connection.zAdd("myset", 2, "Bob")); - actual.add(connection.zAdd("myset", 1, "James")); - actual.add(connection.zRank("myset", "James")); - actual.add(connection.zRank("myset", "Bob")); - verifyResults(Arrays.asList(new Object[] { 1l, 1l, 0l, 1l })); - } - - @Test - public void testZRemRangeByScore() { - convertLongToBoolean = false; - actual.add(connection.zAdd("myset", 2, "Bob")); - actual.add(connection.zAdd("myset", 1, "James")); - actual.add(connection.zRemRangeByScore("myset", 0d, 1d)); - actual.add(connection.zRange("myset", 0l, -1l)); - verifyResults(Arrays.asList(new Object[] { 1l, 1l, 1l, - new LinkedHashSet(Arrays.asList(new String[] { "Bob" })) })); - } - - @Test - public void testZRevRank() { - convertLongToBoolean = false; - actual.add(connection.zAdd("myset", 2, "Bob")); - actual.add(connection.zAdd("myset", 1, "James")); - actual.add(connection.zAdd("myset", 3, "Joe")); - actual.add(connection.zRevRank("myset", "Joe")); - verifyResults(Arrays.asList(new Object[] { 1l, 1l, 1l, 0l })); - } - - @Test - public void testIncrDecrByLong() { - convertLongToBoolean = false; - super.testIncrDecrByLong(); - } - - @Test - public void testIncDecr() { - convertLongToBoolean = false; - super.testIncDecr(); - } - - @Test - public void testType() { - connection.set("something", "yo"); - actual.add(connection.type("something")); - verifyResults(Arrays.asList(new Object[] { "string" })); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testBitCountNonExistentKey() { - convertLongToBoolean = false; - super.testBitCountNonExistentKey(); - } - - @Test - public void testInfo() throws Exception { - convertStringToProps = true; - super.testInfo(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testInfoBySection() throws Exception { - convertStringToProps = true; - super.testInfoBySection(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testDumpAndRestore() { - convert = false; - connection.set("testing", "12"); - actual.add(connection.dump("testing".getBytes())); - List results = getResults(); - initConnection(); - actual.add(connection.del("testing")); - actual.add((connection.get("testing"))); - connection.restore("testing".getBytes(), 0, (byte[]) results.get(results.size() - 1)); - actual.add(connection.get("testing")); - results = getResults(); - assertEquals(3,results.size()); - assertEquals(1l, results.get(0)); - assertNull(results.get(1)); - assertEquals("12", new String((byte[])results.get(2))); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testScriptLoadEvalSha() { - convert = false; - super.testScriptLoadEvalSha(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testEvalShaArrayStrings() { - convert = false; - super.testEvalShaArrayStrings(); - } - - @Test(expected = RedisSystemException.class) - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testRestoreExistingKey() { - convert = false; - super.testRestoreExistingKey(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testEvalReturnString() { - convert = false; - super.testEvalReturnString(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testEvalReturnArrayStrings() { - convert = false; - super.testEvalReturnArrayStrings(); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testEvalReturnSingleOK() { - actual.add(connection.eval("return redis.call('set','abc','ghk')", ReturnType.STATUS, 0)); - assertEquals(Arrays.asList(new Object[] { "OK" }), getResultsNoConversion()); - } - - @SuppressWarnings("unchecked") - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testEvalReturnArrayOKs() { - actual.add(connection.eval( - "return { redis.call('set','abc','ghk'), redis.call('set','abc','lfdf')}", - ReturnType.MULTI, 0)); - List result = (List) getResults().get(0); - assertEquals(Arrays.asList(new Object[] { "OK", "OK" }), result); - } - - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testRestoreTtl() { - convert = false; - super.testRestoreTtl(); - } - @Test(expected = UnsupportedOperationException.class) @IfProfileValue(name = "redisVersion", value = "2.6") public void testScriptKill() { @@ -443,99 +105,14 @@ abstract public class AbstractConnectionTransactionIntegrationTests extends connection.scriptKill(); } - @Test - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testBitCount() { - convertLongToBoolean = false; - String key = "bitset-test"; - connection.setBit(key, 0, false); - connection.setBit(key, 1, true); - connection.setBit(key, 2, true); - actual.add(connection.bitCount(key)); - // Lettuce setBit returns Long instead of void - verifyResults(new ArrayList(Arrays.asList(0l, 0l, 0l, 2l))); - } - - @Test - public void testGetRangeSetRange() { - connection.set("rangekey", "supercalifrag"); - actual.add(connection.getRange("rangekey", 0l, 2l)); - connection.setRange("rangekey", "ck", 2); - actual.add(connection.get("rangekey")); - // Lettuce returns a value for setRange - verifyResults(Arrays.asList(new Object[] { "sup", 13l, "suckrcalifrag" })); - } - protected void initConnection() { connection.multi(); } - protected abstract DataAccessException convertException(Exception ex); - protected List getResults() { - List actual = connection.exec(); - if (actual == null) { - return null; - } - return convertResults(actual); - } - - protected List getResultsNoConversion() { return connection.exec(); } - protected List convertResults(List results) { - if(results == null) { - return null; - } - List serializedResults = new ArrayList(); - for (Object result : results) { - Object convertedResult = convertResult(result); - if (convertedResult instanceof Exception) { - throw convertException((Exception) convertedResult); - } - if (!"OK".equals(convertedResult) && !"QUEUED".equals(convertedResult)) { - serializedResults.add(convertedResult); - } - } - return serializedResults; - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - protected Object convertResult(Object result) { - if (!convert) { - return result; - } - if (result instanceof List && !(((List) result).isEmpty()) - && ((List) result).get(0) instanceof byte[]) { - return (SerializationUtils.deserialize((List) result, stringSerializer)); - } else if (result instanceof byte[]) { - if(convertStringToProps) { - return Converters.toProperties(stringSerializer.deserialize((byte[]) result)); - } - return (stringSerializer.deserialize((byte[]) result)); - } else if (result instanceof Map - && ((Map) result).keySet().iterator().next() instanceof byte[]) { - return (SerializationUtils.deserialize((Map) result, stringSerializer)); - } else if (result instanceof Set && !(((Set) result).isEmpty())) { - Object firstResult = ((Set) result).iterator().next(); - if (firstResult instanceof byte[]) { - return (SerializationUtils.deserialize((Set) result, stringSerializer)); - } - } else if (convertLongToBoolean && result instanceof Long) { - if ((Long) result == 1l) { - return true; - } else if ((Long) result == 0l) { - return false; - } else { - return result; - } - } else if (convertStringToProps && result instanceof String) { - return Converters.toProperties((String) result); - } - return result; - } - protected void verifyResults(List expected) { List expectedTx = new ArrayList(); for (int i = 0; i < actual.size(); i++) { diff --git a/src/test/java/org/springframework/data/redis/connection/ConvertingAbstractConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/ConvertingAbstractConnectionTransactionIntegrationTests.java deleted file mode 100644 index f199118f9..000000000 --- a/src/test/java/org/springframework/data/redis/connection/ConvertingAbstractConnectionTransactionIntegrationTests.java +++ /dev/null @@ -1,125 +0,0 @@ -package org.springframework.data.redis.connection; - -import static org.junit.Assert.assertEquals; - -import java.util.ArrayList; -import java.util.List; - -import org.junit.Ignore; -import org.junit.Test; -import org.springframework.test.annotation.IfProfileValue; - -public class ConvertingAbstractConnectionTransactionIntegrationTests extends - AbstractConnectionIntegrationTests { - - @Ignore - public void testMultiDiscard() { - } - - @Ignore - public void testMultiExec() { - } - - @Ignore - public void testUnwatch() { - } - - @Ignore - public void testWatch() { - } - - @Ignore - @Test - public void testExecWithoutMulti() { - } - - @Ignore - @Test - public void testErrorInTx() { - } - - /* - * Using blocking ops inside a tx does not make a lot of sense as it would require blocking the - * entire server in order to execute the block atomically, which in turn does not allow other - * clients to perform a push operation. * - */ - - @Ignore - public void testBLPop() { - } - - @Ignore - public void testBRPop() { - } - - @Ignore - public void testBRPopLPush() { - } - - @Ignore - public void testBLPopTimeout() { - } - - @Ignore - public void testBRPopTimeout() { - } - - @Ignore - public void testBRPopLPushTimeout() { - } - - @Ignore("Pub/Sub not supported with transactions") - public void testPubSubWithNamedChannels() throws Exception { - } - - @Ignore("Pub/Sub not supported with transactions") - public void testPubSubWithPatterns() throws Exception { - } - - @Ignore - public void testNullKey() throws Exception { - } - - @Ignore - public void testNullValue() throws Exception { - } - - @Ignore - public void testHashNullKey() throws Exception { - } - - @Ignore - public void testHashNullValue() throws Exception { - } - - @Test(expected = UnsupportedOperationException.class) - public void testWatchWhileInTx() { - connection.watch("foo".getBytes()); - } - - @Test(expected = UnsupportedOperationException.class) - @IfProfileValue(name = "redisVersion", value = "2.6") - public void testScriptKill() { - // Impossible to call script kill in a tx because you can't issue the - // exec command while Redis is running a script - connection.scriptKill(); - } - - protected void initConnection() { - connection.multi(); - } - - protected List getResults() { - return connection.exec(); - } - - protected void verifyResults(List expected) { - List expectedTx = new ArrayList(); - for (int i = 0; i < actual.size(); i++) { - expectedTx.add(null); - } - assertEquals(expectedTx, actual); - List results = getResults(); - assertEquals(expected, results); - } -} diff --git a/src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionTransactionIntegrationTests.java index 2af15fae9..88245f43c 100644 --- a/src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionTransactionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionTransactionIntegrationTests.java @@ -19,7 +19,7 @@ import org.junit.After; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; -import org.springframework.data.redis.connection.ConvertingAbstractConnectionTransactionIntegrationTests; +import org.springframework.data.redis.connection.AbstractConnectionTransactionIntegrationTests; import org.springframework.test.annotation.IfProfileValue; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @@ -37,7 +37,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("JedisConnectionIntegrationTests-context.xml") public class JedisConnectionTransactionIntegrationTests extends - ConvertingAbstractConnectionTransactionIntegrationTests { + AbstractConnectionTransactionIntegrationTests { @After public void tearDown() { diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionIntegrationTests.java index da51376ae..fe019ee78 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionIntegrationTests.java @@ -23,7 +23,6 @@ import static org.junit.Assume.assumeTrue; import static org.springframework.data.redis.SpinBarrier.waitFor; import java.util.Arrays; -import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; import org.junit.Test; @@ -44,7 +43,6 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import com.lambdaworks.redis.RedisAsyncConnection; -import com.lambdaworks.redis.RedisException; /** * Integration test of {@link LettuceConnection} @@ -286,16 +284,4 @@ public class LettuceConnectionIntegrationTests extends AbstractConnectionIntegra conn2.close(); } } - - @Test - public void testErrorInTx() { - connection.multi(); - connection.set("foo","bar"); - // Try to do a list op on a value - connection.lPop("foo"); - List execResults = connection.exec(); - // Lettuce puts the Exception in the exec results instead of throwing an Exception on exec - // This should be fixed in DATAREDIS-208 when we convert results of tx.exec() - assertTrue(execResults.get(1) instanceof RedisException); - } } \ No newline at end of file diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineIntegrationTests.java index 898d5db5e..4369cbf25 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineIntegrationTests.java @@ -21,7 +21,6 @@ import static org.junit.Assume.assumeTrue; import static org.springframework.data.redis.SpinBarrier.waitFor; import java.util.Arrays; -import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; import org.junit.Test; @@ -39,8 +38,6 @@ import org.springframework.test.annotation.IfProfileValue; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.lambdaworks.redis.RedisException; - /** * Integration test of {@link LettuceConnection} pipeline functionality * @@ -129,19 +126,4 @@ public class LettuceConnectionPipelineIntegrationTests extends conn2.close(); } } - - @SuppressWarnings("unchecked") - @Test - public void testErrorInTx() { - connection.multi(); - connection.set("foo","bar"); - // Try to do a list op on a value - connection.lPop("foo"); - connection.exec(); - List results = getResults(); - List execResults = (List)results.get(0); - // Lettuce puts the Exception in the exec results instead of throwing an Exception on exec - // This should be fixed in DATAREDIS-208 when we convert results of tx.exec() - assertTrue(execResults.get(1) instanceof RedisException); - } } diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineTxIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineTxIntegrationTests.java index f397fcc82..1dd3c8a15 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineTxIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionPipelineTxIntegrationTests.java @@ -5,6 +5,10 @@ import static org.junit.Assert.assertNull; import java.util.List; +import org.junit.Test; +import org.springframework.data.redis.connection.RedisPipelineException; +import org.springframework.test.annotation.IfProfileValue; + /** * Integration test of {@link LettuceConnection} transactions within a pipeline * @@ -14,6 +18,30 @@ import java.util.List; public class LettuceConnectionPipelineTxIntegrationTests extends LettuceConnectionTransactionIntegrationTests { + @Test(expected = RedisPipelineException.class) + @IfProfileValue(name = "redisVersion", value = "2.6") + public void testEvalShaNotFound() { + super.testEvalShaNotFound(); + } + + @Test(expected = RedisPipelineException.class) + @IfProfileValue(name = "redisVersion", value = "2.6") + public void testEvalReturnSingleError() { + super.testEvalReturnSingleError(); + } + + @Test(expected = RedisPipelineException.class) + @IfProfileValue(name = "redisVersion", value = "2.6") + public void testRestoreBadData() { + super.testRestoreBadData(); + } + + @Test(expected = RedisPipelineException.class) + @IfProfileValue(name = "redisVersion", value = "2.6") + public void testRestoreExistingKey() { + super.testRestoreExistingKey(); + } + protected void initConnection() { connection.openPipeline(); connection.multi(); @@ -21,17 +49,6 @@ public class LettuceConnectionPipelineTxIntegrationTests extends @SuppressWarnings("unchecked") protected List getResults() { - assertNull(connection.exec()); - List pipelined = connection.closePipeline(); - // We expect only the results of exec to be in the closed pipeline - assertEquals(1,pipelined.size()); - List txResults = (List)pipelined.get(0); - // Return exec results and this test should behave exactly like its superclass - return convertResults(txResults); - } - - @SuppressWarnings("unchecked") - protected List getResultsNoConversion() { assertNull(connection.exec()); List pipelined = connection.closePipeline(); // We expect only the results of exec to be in the closed pipeline diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionTransactionIntegrationTests.java index d3b62ddee..cbdc9d390 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionTransactionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionTransactionIntegrationTests.java @@ -17,31 +17,18 @@ package org.springframework.data.redis.connection.lettuce; import static org.junit.Assert.assertEquals; -import java.util.ArrayList; import java.util.Arrays; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; -import org.springframework.core.convert.converter.Converter; -import org.springframework.dao.DataAccessException; import org.springframework.data.redis.connection.AbstractConnectionTransactionIntegrationTests; import org.springframework.data.redis.connection.DefaultStringRedisConnection; -import org.springframework.data.redis.connection.DefaultStringTuple; -import org.springframework.data.redis.connection.RedisZSetCommands.Tuple; import org.springframework.data.redis.connection.StringRedisConnection; -import org.springframework.data.redis.connection.StringRedisConnection.StringTuple; -import org.springframework.data.redis.connection.convert.SetConverter; import org.springframework.test.annotation.IfProfileValue; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.lambdaworks.redis.KeyValue; -import com.lambdaworks.redis.ScoredValue; - /** * Integration test of {@link LettuceConnection} functionality within a * transaction @@ -54,141 +41,11 @@ import com.lambdaworks.redis.ScoredValue; public class LettuceConnectionTransactionIntegrationTests extends AbstractConnectionTransactionIntegrationTests { - private boolean convertListToSet; - - @Test - @Ignore("Exceptions on native execute are swallowed in tx") + @Ignore("DATAREDIS-226 Exceptions on native execute are swallowed in tx") public void exceptionExecuteNative() throws Exception { } - // Native Lettuce returns ZSets as Lists - @Test - public void testZAddAndZRange() { - convertListToSet = true; - super.testZAddAndZRange(); - } - - @Test - public void testZIncrBy() { - convertListToSet = true; - super.testZIncrBy(); - } - - @Test - public void testZInterStore() { - convertListToSet = true; - super.testZInterStore(); - } - - @Test - public void testZInterStoreAggWeights() { - convertListToSet = true; - super.testZInterStoreAggWeights(); - } - - @Test - public void testZRangeWithScores() { - convertListToSet = true; - super.testZRangeWithScores(); - } - - @Test - public void testZRangeByScore() { - convertListToSet = true; - super.testZRangeByScore(); - } - - @Test - public void testZRangeByScoreOffsetCount() { - convertListToSet = true; - super.testZRangeByScoreOffsetCount(); - } - - @Test - public void testZRangeByScoreWithScores() { - convertListToSet = true; - super.testZRangeByScoreWithScores(); - } - - @Test - public void testZRangeByScoreWithScoresOffsetCount() { - convertListToSet = true; - super.testZRangeByScoreWithScoresOffsetCount(); - } - - @Test - public void testZRevRangeByScoreOffsetCount() { - convertListToSet = true; - super.testZRevRangeByScoreOffsetCount(); - } - - @Test - public void testZRevRangeByScore() { - convertListToSet = true; - super.testZRevRangeByScore(); - } - - @Test - public void testZRevRange() { - convertListToSet = true; - super.testZRevRange(); - } - - @Test - public void testZRevRangeWithScores() { - convertListToSet = true; - super.testZRevRangeWithScores(); - } - - @Test - public void testZRem() { - convertListToSet = true; - super.testZRem(); - } - - @Test - public void testZRemRangeByRank() { - convertListToSet = true; - super.testZRemRangeByRank(); - } - - @Test - public void testZRemRangeByScore() { - convertListToSet = true; - super.testZRemRangeByScore(); - } - - @Test - public void testZUnionStore() { - convertListToSet = true; - super.testZUnionStore(); - } - - @Test - public void testZUnionStoreAggWeights() { - convertListToSet = true; - super.testZUnionStoreAggWeights(); - } - - @Test - public void testBitSet() throws Exception { - convertLongToBoolean = false; - String key = "bitset-test"; - connection.setBit(key, 0, false); - connection.setBit(key, 1, true); - actual.add(connection.getBit(key, 0)); - actual.add(connection.getBit(key, 1)); - // Lettuce setBit returns Long instead of void - verifyResults(Arrays.asList(new Object[] { 0l, 0l, 0l, 1l })); - } - - @Test - public void testHKeys() { - convertListToSet = true; - super.testHKeys(); - } - @Test(expected = UnsupportedOperationException.class) public void testBitOpNotMultipleSources() { super.testBitOpNotMultipleSources(); @@ -200,12 +57,6 @@ public class LettuceConnectionTransactionIntegrationTests extends super.testSRandMemberCountNegative(); } - @Test - public void testSortStoreNullParams() { - convertLongToBoolean = false; - super.testSortStoreNullParams(); - } - @Test public void testMove() { connection.set("foo", "bar"); @@ -230,43 +81,4 @@ public class LettuceConnectionTransactionIntegrationTests extends public void testSelect() { super.testSelect(); } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - @Override - protected Object convertResult(Object result) { - if (!convert) { - return result; - } - Object convertedResult = super.convertResult(result); - if (convertedResult instanceof KeyValue) { - List keyValue = new ArrayList(); - keyValue.add((String) super.convertResult(((KeyValue) convertedResult).key)); - keyValue.add((String) super.convertResult(((KeyValue) convertedResult).value)); - return keyValue; - } - if (convertedResult instanceof List && !(((List) result).isEmpty()) - && ((List) convertedResult).get(0) instanceof ScoredValue) { - Set tuples = LettuceConverters.toTupleSet((List) convertedResult); - return new SetConverter(new TupleConverter()) - .convert(tuples); - } - if (convertListToSet && convertedResult instanceof List) { - return new LinkedHashSet((List) convertedResult); - } - if (convertStringToProps && convertedResult instanceof String) { - return LettuceConverters.toProperties((String) convertedResult); - } - return convertedResult; - } - - private class TupleConverter implements Converter { - public StringTuple convert(Tuple source) { - return new DefaultStringTuple(source, stringSerializer.deserialize(source.getValue())); - } - } - - @Override - protected DataAccessException convertException(Exception ex) { - return LettuceConverters.toDataAccessException(ex); - } } diff --git a/src/test/java/org/springframework/data/redis/connection/srp/SrpConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/srp/SrpConnectionTransactionIntegrationTests.java index dc19aee66..d008f3cf1 100644 --- a/src/test/java/org/springframework/data/redis/connection/srp/SrpConnectionTransactionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/srp/SrpConnectionTransactionIntegrationTests.java @@ -19,7 +19,7 @@ import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; -import org.springframework.data.redis.connection.ConvertingAbstractConnectionTransactionIntegrationTests; +import org.springframework.data.redis.connection.AbstractConnectionTransactionIntegrationTests; import org.springframework.data.redis.connection.ReturnType; import org.springframework.test.annotation.IfProfileValue; import org.springframework.test.context.ContextConfiguration; @@ -35,7 +35,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("SrpConnectionIntegrationTests-context.xml") -public class SrpConnectionTransactionIntegrationTests extends ConvertingAbstractConnectionTransactionIntegrationTests { +public class SrpConnectionTransactionIntegrationTests extends AbstractConnectionTransactionIntegrationTests { @Test @IfProfileValue(name = "redisVersion", value = "2.6")