rik/jlibredis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into introduce-new-sentinel-commands-added-to-Redis-2.8

Browse Source 
Conflicts:
	Makefile
	src/main/java/redis/clients/jedis/Jedis.java
This commit is contained in:
Jungtaek Lim
2014-02-05 00:26:14 +09:00
parent 68356eb802 2d04a3845b
commit 6efeb45952
100 changed files with 6206 additions and 5711 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -208,8 +208,8 @@ start: cleanup
echo "$$REDIS_CLUSTER_NODE3_CONF" | redis-server - echo "$$REDIS_CLUSTER_NODE3_CONF" | redis-server -
cleanup: cleanup:
rm -vf /tmp/redis_cluster_node*.conf - rm -vf /tmp/redis_cluster_node*.conf 2>/dev/null
rm -vf /tmp/sentinel*.conf - rm dump.rdb appendonly.aof - 2>/dev/null
stop: stop:
kill `cat /tmp/redis1.pid` kill `cat /tmp/redis1.pid`

2
README.md
View File

@@ -73,7 +73,7 @@ Redis cluster [specification](http://redis.io/topics/cluster-spec) (still under
```java ```java
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>(); Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
//Jedis Cluster will attempt to discover cluster nodes automatically //Jedis Cluster will attempt to discover cluster nodes automatically
jedisClusterNode.add(new HostAndPort("127.0.0.1", 7379)); jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7379));
JedisCluster jc = new JedisCluster(jedisClusterNode); JedisCluster jc = new JedisCluster(jedisClusterNode);
jc.set("foo", "bar"); jc.set("foo", "bar");
String value = jc.get("foo"); String value = jc.get("foo");

2
pom.xml
View File

@@ -9,7 +9,7 @@
<packaging>jar</packaging> <packaging>jar</packaging>
<groupId>redis.clients</groupId> <groupId>redis.clients</groupId>
<artifactId>jedis</artifactId> <artifactId>jedis</artifactId>
<version>2.2.2-SNAPSHOT</version> <version>2.3.1-SNAPSHOT</version>
<name>Jedis</name> <name>Jedis</name>
<description>Jedis is a blazingly small and sane Redis java client.</description> <description>Jedis is a blazingly small and sane Redis java client.</description>
<url>https://github.com/xetorthio/jedis</url> <url>https://github.com/xetorthio/jedis</url>

1
src/main/java/redis/clients/jedis/AdvancedBinaryJedisCommands.java
View File

@@ -1,6 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
public interface AdvancedBinaryJedisCommands { public interface AdvancedBinaryJedisCommands {

3
src/main/java/redis/clients/jedis/AdvancedJedisCommands.java
View File

@@ -1,9 +1,8 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.util.Slowlog;
import java.util.List; import java.util.List;
import redis.clients.util.Slowlog;
public interface AdvancedJedisCommands { public interface AdvancedJedisCommands {
List<String> configGet(String pattern); List<String> configGet(String pattern);

4
src/main/java/redis/clients/jedis/BasicCommands.java
View File

@@ -27,7 +27,7 @@ public interface BasicCommands {
String shutdown(); String shutdown();
String info(); String info();
String info(String section); String info(String section);
String slaveof(String host, int port); String slaveof(String host, int port);
@@ -39,6 +39,6 @@ public interface BasicCommands {
String debug(DebugParams params); String debug(DebugParams params);
String configResetStat(); String configResetStat();
Long waitReplicas(int replicas, long timeout); Long waitReplicas(int replicas, long timeout);
} }

1
src/main/java/redis/clients/jedis/BasicRedisPipeline.java
View File

@@ -1,6 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
/** /**
* Pipelined responses for all of the low level, non key related commands * Pipelined responses for all of the low level, non key related commands
*/ */

456
src/main/java/redis/clients/jedis/BinaryClient.java
View File

@@ -1,22 +1,26 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.jedis.Protocol.Command; import static redis.clients.jedis.Protocol.toByteArray;
import redis.clients.jedis.Protocol.Keyword; import static redis.clients.jedis.Protocol.Command.*;
import redis.clients.util.SafeEncoder; import static redis.clients.jedis.Protocol.Keyword.ENCODING;
import static redis.clients.jedis.Protocol.Keyword.IDLETIME;
import static redis.clients.jedis.Protocol.Keyword.LEN;
import static redis.clients.jedis.Protocol.Keyword.LIMIT;
import static redis.clients.jedis.Protocol.Keyword.NO;
import static redis.clients.jedis.Protocol.Keyword.ONE;
import static redis.clients.jedis.Protocol.Keyword.REFCOUNT;
import static redis.clients.jedis.Protocol.Keyword.RESET;
import static redis.clients.jedis.Protocol.Keyword.STORE;
import static redis.clients.jedis.Protocol.Keyword.WITHSCORES;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import static redis.clients.jedis.Protocol.Command.*; import redis.clients.jedis.Protocol.Command;
import static redis.clients.jedis.Protocol.Command.EXISTS; import redis.clients.jedis.Protocol.Keyword;
import static redis.clients.jedis.Protocol.Command.PSUBSCRIBE; import redis.clients.util.SafeEncoder;
import static redis.clients.jedis.Protocol.Command.PUNSUBSCRIBE;
import static redis.clients.jedis.Protocol.Command.SUBSCRIBE;
import static redis.clients.jedis.Protocol.Command.UNSUBSCRIBE;
import static redis.clients.jedis.Protocol.Keyword.*;
import static redis.clients.jedis.Protocol.toByteArray;
public class BinaryClient extends Connection { public class BinaryClient extends Connection {
public enum LIST_POSITION { public enum LIST_POSITION {
@@ -34,10 +38,16 @@ public class BinaryClient extends Connection {
private long db; private long db;
private boolean isInWatch;
public boolean isInMulti() { public boolean isInMulti() {
return isInMulti; return isInMulti;
} }
public boolean isInWatch() {
return isInWatch;
}
public BinaryClient(final String host) { public BinaryClient(final String host) {
super(host); super(host);
} }
@@ -82,11 +92,11 @@ public class BinaryClient extends Connection {
sendCommand(Command.SET, key, value); sendCommand(Command.SET, key, value);
} }
public void set(final byte[] key, final byte[] value, final byte[] nxxx, final byte[] expx, final long time) { public void set(final byte[] key, final byte[] value, final byte[] nxxx,
sendCommand(Command.SET, key, value, nxxx, expx, toByteArray(time)); final byte[] expx, final long time) {
sendCommand(Command.SET, key, value, nxxx, expx, toByteArray(time));
} }
public void get(final byte[] key) { public void get(final byte[] key) {
sendCommand(Command.GET, key); sendCommand(Command.GET, key);
} }
@@ -377,15 +387,16 @@ public class BinaryClient extends Connection {
sendCommand(ZADD, key, toByteArray(score), member); sendCommand(ZADD, key, toByteArray(score), member);
} }
public void zaddBinary(final byte[] key, Map<Double, byte[]> scoreMembers) { public void zaddBinary(final byte[] key,
final Map<byte[], Double> scoreMembers) {
ArrayList<byte[]> args = new ArrayList<byte[]>( ArrayList<byte[]> args = new ArrayList<byte[]>(
scoreMembers.size() * 2 + 1); scoreMembers.size() * 2 + 1);
args.add(key); args.add(key);
for (Map.Entry<Double, byte[]> entry : scoreMembers.entrySet()) { for (Map.Entry<byte[], Double> entry : scoreMembers.entrySet()) {
args.add(toByteArray(entry.getKey())); args.add(toByteArray(entry.getValue()));
args.add(entry.getValue()); args.add(entry.getKey());
} }
byte[][] argsArray = new byte[args.size()][]; byte[][] argsArray = new byte[args.size()][];
@@ -447,19 +458,23 @@ public class BinaryClient extends Connection {
public void discard() { public void discard() {
sendCommand(DISCARD); sendCommand(DISCARD);
isInMulti = false; isInMulti = false;
isInWatch = false;
} }
public void exec() { public void exec() {
sendCommand(EXEC); sendCommand(EXEC);
isInMulti = false; isInMulti = false;
isInWatch = false;
} }
public void watch(final byte[]... keys) { public void watch(final byte[]... keys) {
sendCommand(WATCH, keys); sendCommand(WATCH, keys);
isInWatch = true;
} }
public void unwatch() { public void unwatch() {
sendCommand(UNWATCH); sendCommand(UNWATCH);
isInWatch = false;
} }
public void sort(final byte[] key) { public void sort(final byte[] key) {
@@ -476,14 +491,14 @@ public class BinaryClient extends Connection {
public void blpop(final byte[][] args) { public void blpop(final byte[][] args) {
sendCommand(BLPOP, args); sendCommand(BLPOP, args);
} }
public void blpop(final int timeout, final byte[]... keys) { public void blpop(final int timeout, final byte[]... keys) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
for (final byte[] arg : keys) { for (final byte[] arg : keys) {
args.add(arg); args.add(arg);
} }
args.add(Protocol.toByteArray(timeout)); args.add(Protocol.toByteArray(timeout));
blpop(args.toArray(new byte[args.size()][])); blpop(args.toArray(new byte[args.size()][]));
} }
public void sort(final byte[] key, final SortingParams sortingParameters, public void sort(final byte[] key, final SortingParams sortingParameters,
@@ -503,14 +518,14 @@ public class BinaryClient extends Connection {
public void brpop(final byte[][] args) { public void brpop(final byte[][] args) {
sendCommand(BRPOP, args); sendCommand(BRPOP, args);
} }
public void brpop(final int timeout, final byte[]... keys) { public void brpop(final int timeout, final byte[]... keys) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
for (final byte[] arg : keys) { for (final byte[] arg : keys) {
args.add(arg); args.add(arg);
} }
args.add(Protocol.toByteArray(timeout)); args.add(Protocol.toByteArray(timeout));
brpop(args.toArray(new byte[args.size()][])); brpop(args.toArray(new byte[args.size()][]));
} }
public void auth(final String password) { public void auth(final String password) {
@@ -543,32 +558,39 @@ public class BinaryClient extends Connection {
} }
public void punsubscribe(final byte[]... patterns) { public void punsubscribe(final byte[]... patterns) {
sendCommand(PUNSUBSCRIBE, patterns); sendCommand(PUNSUBSCRIBE, patterns);
}
public void pubsub(final byte[]... args) {
sendCommand(PUBSUB, args);
} }
public void zcount(final byte[] key, final double min, final double max) { public void zcount(final byte[] key, final double min, final double max) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZCOUNT, key, byteArrayMin, byteArrayMax); sendCommand(ZCOUNT, key, byteArrayMin, byteArrayMax);
} }
public void zcount(final byte[] key, final byte min[], final byte max[]) { public void zcount(final byte[] key, final byte min[], final byte max[]) {
sendCommand(ZCOUNT, key, min, max); sendCommand(ZCOUNT, key, min, max);
} }
public void zcount(final byte[] key, final String min, final String max) { public void zcount(final byte[] key, final String min, final String max) {
sendCommand(ZCOUNT, key, min.getBytes(), max.getBytes()); sendCommand(ZCOUNT, key, min.getBytes(), max.getBytes());
} }
public void zrangeByScore(final byte[] key, final double min, public void zrangeByScore(final byte[] key, final double min,
final double max) { final double max) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax); sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax);
} }
public void zrangeByScore(final byte[] key, final byte[] min, public void zrangeByScore(final byte[] key, final byte[] min,
@@ -577,17 +599,19 @@ public class BinaryClient extends Connection {
} }
public void zrangeByScore(final byte[] key, final String min, public void zrangeByScore(final byte[] key, final String min,
final String max) { final String max) {
sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes()); sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes());
} }
public void zrevrangeByScore(final byte[] key, final double max, public void zrevrangeByScore(final byte[] key, final double max,
final double min) { final double min) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin); sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin);
} }
public void zrevrangeByScore(final byte[] key, final byte[] max, public void zrevrangeByScore(final byte[] key, final byte[] max,
@@ -596,114 +620,125 @@ public class BinaryClient extends Connection {
} }
public void zrevrangeByScore(final byte[] key, final String max, public void zrevrangeByScore(final byte[] key, final String max,
final String min) { final String min) {
sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes()); sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes());
} }
public void zrangeByScore(final byte[] key, final double min, public void zrangeByScore(final byte[] key, final double min,
final double max, final int offset, int count) { final double max, final int offset, int count) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax, sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax, LIMIT.raw,
LIMIT.raw, toByteArray(offset), toByteArray(count)); toByteArray(offset), toByteArray(count));
} }
public void zrangeByScore(final byte[] key, final String min,
final String max, final int offset, int count) {
sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(), public void zrangeByScore(final byte[] key, final String min,
LIMIT.raw, toByteArray(offset), toByteArray(count)); final String max, final int offset, int count) {
sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(),
LIMIT.raw, toByteArray(offset), toByteArray(count));
} }
public void zrevrangeByScore(final byte[] key, final double max, public void zrevrangeByScore(final byte[] key, final double max,
final double min, final int offset, int count) { final double min, final int offset, int count) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin, sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin,
LIMIT.raw, toByteArray(offset), toByteArray(count)); LIMIT.raw, toByteArray(offset), toByteArray(count));
} }
public void zrevrangeByScore(final byte[] key, final String max, public void zrevrangeByScore(final byte[] key, final String max,
final String min, final int offset, int count) { final String min, final int offset, int count) {
sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(), sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(),
LIMIT.raw, toByteArray(offset), toByteArray(count)); LIMIT.raw, toByteArray(offset), toByteArray(count));
} }
public void zrangeByScoreWithScores(final byte[] key, final double min, public void zrangeByScoreWithScores(final byte[] key, final double min,
final double max) { final double max) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax, sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax,
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrangeByScoreWithScores(final byte[] key, final String min, public void zrangeByScoreWithScores(final byte[] key, final String min,
final String max) { final String max) {
sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(), sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(),
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrevrangeByScoreWithScores(final byte[] key, final double max, public void zrevrangeByScoreWithScores(final byte[] key, final double max,
final double min) { final double min) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin, sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin,
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrevrangeByScoreWithScores(final byte[] key, final String max, public void zrevrangeByScoreWithScores(final byte[] key, final String max,
final String min) { final String min) {
sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(), sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(),
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrangeByScoreWithScores(final byte[] key, final double min, public void zrangeByScoreWithScores(final byte[] key, final double min,
final double max, final int offset, final int count) { final double max, final int offset, final int count) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax, sendCommand(ZRANGEBYSCORE, key, byteArrayMin, byteArrayMax, LIMIT.raw,
LIMIT.raw, toByteArray(offset), toByteArray(count), toByteArray(offset), toByteArray(count), WITHSCORES.raw);
WITHSCORES.raw);
} }
public void zrangeByScoreWithScores(final byte[] key, final String min, public void zrangeByScoreWithScores(final byte[] key, final String min,
final String max, final int offset, final int count) { final String max, final int offset, final int count) {
sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(), sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(),
LIMIT.raw, toByteArray(offset), toByteArray(count), LIMIT.raw, toByteArray(offset), toByteArray(count),
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrevrangeByScoreWithScores(final byte[] key, final double max, public void zrevrangeByScoreWithScores(final byte[] key, final double max,
final double min, final int offset, final int count) { final double min, final int offset, final int count) {
byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf".getBytes() : toByteArray(min); byte byteArrayMin[] = (min == Double.NEGATIVE_INFINITY) ? "-inf"
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf".getBytes() : toByteArray(max); .getBytes() : toByteArray(min);
byte byteArrayMax[] = (max == Double.POSITIVE_INFINITY) ? "+inf"
.getBytes() : toByteArray(max);
sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin, sendCommand(ZREVRANGEBYSCORE, key, byteArrayMax, byteArrayMin,
LIMIT.raw, toByteArray(offset), toByteArray(count), LIMIT.raw, toByteArray(offset), toByteArray(count),
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrevrangeByScoreWithScores(final byte[] key, final String max, public void zrevrangeByScoreWithScores(final byte[] key, final String max,
final String min, final int offset, final int count) { final String min, final int offset, final int count) {
sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(), sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(),
LIMIT.raw, toByteArray(offset), toByteArray(count), LIMIT.raw, toByteArray(offset), toByteArray(count),
WITHSCORES.raw); WITHSCORES.raw);
} }
public void zrangeByScore(final byte[] key, final byte[] min, public void zrangeByScore(final byte[] key, final byte[] min,
final byte[] max, final int offset, int count) { final byte[] max, final int offset, int count) {
sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.raw, sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.raw,
@@ -746,11 +781,11 @@ public class BinaryClient extends Connection {
public void zremrangeByScore(final byte[] key, final byte[] start, public void zremrangeByScore(final byte[] key, final byte[] start,
final byte[] end) { final byte[] end) {
sendCommand(ZREMRANGEBYSCORE, key, start, end); sendCommand(ZREMRANGEBYSCORE, key, start, end);
} }
public void zremrangeByScore(final byte[] key, final String start, public void zremrangeByScore(final byte[] key, final String start,
final String end) { final String end) {
sendCommand(ZREMRANGEBYSCORE, key, start.getBytes(), end.getBytes()); sendCommand(ZREMRANGEBYSCORE, key, start.getBytes(), end.getBytes());
} }
public void zunionstore(final byte[] dstkey, final byte[]... sets) { public void zunionstore(final byte[] dstkey, final byte[]... sets) {
@@ -816,7 +851,7 @@ public class BinaryClient extends Connection {
public void info() { public void info() {
sendCommand(INFO); sendCommand(INFO);
} }
public void info(final String section) { public void info(final String section) {
sendCommand(INFO, section); sendCommand(INFO, section);
} }
@@ -888,7 +923,7 @@ public class BinaryClient extends Connection {
} }
public void setbit(byte[] key, long offset, boolean value) { public void setbit(byte[] key, long offset, boolean value) {
sendCommand(SETBIT, key, toByteArray(offset), toByteArray(value)); sendCommand(SETBIT, key, toByteArray(offset), toByteArray(value));
} }
public void getbit(byte[] key, long offset) { public void getbit(byte[] key, long offset) {
@@ -913,6 +948,14 @@ public class BinaryClient extends Connection {
super.disconnect(); super.disconnect();
} }
public void resetState() {
if (isInMulti())
discard();
if (isInWatch())
unwatch();
}
private void sendEvalCommand(Command command, byte[] script, private void sendEvalCommand(Command command, byte[] script,
byte[] keyCount, byte[][] params) { byte[] keyCount, byte[][] params) {
@@ -932,7 +975,7 @@ public class BinaryClient extends Connection {
} }
public void eval(byte[] script, int keyCount, byte[]... params) { public void eval(byte[] script, int keyCount, byte[]... params) {
eval(script, toByteArray(keyCount), params); eval(script, toByteArray(keyCount), params);
} }
public void evalsha(byte[] sha1, byte[] keyCount, byte[]... params) { public void evalsha(byte[] sha1, byte[] keyCount, byte[]... params) {
@@ -940,7 +983,7 @@ public class BinaryClient extends Connection {
} }
public void evalsha(byte[] sha1, int keyCount, byte[]... params) { public void evalsha(byte[] sha1, int keyCount, byte[]... params) {
sendEvalCommand(EVALSHA, sha1, toByteArray(keyCount), params); sendEvalCommand(EVALSHA, sha1, toByteArray(keyCount), params);
} }
public void scriptFlush() { public void scriptFlush() {
@@ -993,153 +1036,160 @@ public class BinaryClient extends Connection {
} }
public void bitcount(byte[] key) { public void bitcount(byte[] key) {
sendCommand(BITCOUNT, key); sendCommand(BITCOUNT, key);
} }
public void bitcount(byte[] key, long start, long end) { public void bitcount(byte[] key, long start, long end) {
sendCommand(BITCOUNT, key, toByteArray(start), toByteArray(end)); sendCommand(BITCOUNT, key, toByteArray(start), toByteArray(end));
} }
public void bitop(BitOP op, byte[] destKey, byte[]... srcKeys) { public void bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
Keyword kw = Keyword.AND; Keyword kw = Keyword.AND;
int len = srcKeys.length; int len = srcKeys.length;
switch (op) { switch (op) {
case AND: case AND:
kw = Keyword.AND; kw = Keyword.AND;
break; break;
case OR: case OR:
kw = Keyword.OR; kw = Keyword.OR;
break; break;
case XOR: case XOR:
kw = Keyword.XOR; kw = Keyword.XOR;
break; break;
case NOT: case NOT:
kw = Keyword.NOT; kw = Keyword.NOT;
len = Math.min(1, len); len = Math.min(1, len);
break; break;
} }
byte[][] bargs = new byte[len + 2][]; byte[][] bargs = new byte[len + 2][];
bargs[0] = kw.raw; bargs[0] = kw.raw;
bargs[1] = destKey; bargs[1] = destKey;
for (int i = 0; i < len; ++i) { for (int i = 0; i < len; ++i) {
bargs[i + 2] = srcKeys[i]; bargs[i + 2] = srcKeys[i];
} }
sendCommand(BITOP, bargs); sendCommand(BITOP, bargs);
} }
public void sentinel(final byte[]... args) { public void sentinel(final byte[]... args) {
sendCommand(SENTINEL, args); sendCommand(SENTINEL, args);
} }
public void dump(final byte[] key) { public void dump(final byte[] key) {
sendCommand(DUMP, key); sendCommand(DUMP, key);
} }
public void restore(final byte[] key, final int ttl, final byte[] serializedValue) { public void restore(final byte[] key, final int ttl,
sendCommand(RESTORE, key, toByteArray(ttl), serializedValue); final byte[] serializedValue) {
sendCommand(RESTORE, key, toByteArray(ttl), serializedValue);
} }
public void pexpire(final byte[] key, final int milliseconds) { public void pexpire(final byte[] key, final int milliseconds) {
sendCommand(PEXPIRE, key, toByteArray(milliseconds)); sendCommand(PEXPIRE, key, toByteArray(milliseconds));
} }
public void pexpireAt(final byte[] key, final long millisecondsTimestamp) { public void pexpireAt(final byte[] key, final long millisecondsTimestamp) {
sendCommand(PEXPIREAT, key, toByteArray(millisecondsTimestamp)); sendCommand(PEXPIREAT, key, toByteArray(millisecondsTimestamp));
} }
public void pttl(final byte[] key) { public void pttl(final byte[] key) {
sendCommand(PTTL, key); sendCommand(PTTL, key);
} }
public void incrByFloat(final byte[] key, final double increment) { public void incrByFloat(final byte[] key, final double increment) {
sendCommand(INCRBYFLOAT, key, toByteArray(increment)); sendCommand(INCRBYFLOAT, key, toByteArray(increment));
} }
public void psetex(final byte[] key, final int milliseconds, final byte[] value) { public void psetex(final byte[] key, final int milliseconds,
sendCommand(PSETEX, key, toByteArray(milliseconds), value); final byte[] value) {
sendCommand(PSETEX, key, toByteArray(milliseconds), value);
} }
public void set(final byte[] key, final byte[] value, final byte[] nxxx) { public void set(final byte[] key, final byte[] value, final byte[] nxxx) {
sendCommand(Command.SET, key, value, nxxx); sendCommand(Command.SET, key, value, nxxx);
} }
public void set(final byte[] key, final byte[] value, final byte[] nxxx, final byte[] expx, final int time) { public void set(final byte[] key, final byte[] value, final byte[] nxxx,
sendCommand(Command.SET, key, value, nxxx, expx, toByteArray(time)); final byte[] expx, final int time) {
sendCommand(Command.SET, key, value, nxxx, expx, toByteArray(time));
} }
public void srandmember(final byte[] key, final int count) { public void srandmember(final byte[] key, final int count) {
sendCommand(SRANDMEMBER, key, toByteArray(count)); sendCommand(SRANDMEMBER, key, toByteArray(count));
} }
public void clientKill(final byte[] client) { public void clientKill(final byte[] client) {
sendCommand(CLIENT, Keyword.KILL.raw, client); sendCommand(CLIENT, Keyword.KILL.raw, client);
} }
public void clientGetname() { public void clientGetname() {
sendCommand(CLIENT, Keyword.GETNAME.raw); sendCommand(CLIENT, Keyword.GETNAME.raw);
} }
public void clientList() { public void clientList() {
sendCommand(CLIENT, Keyword.LIST.raw); sendCommand(CLIENT, Keyword.LIST.raw);
} }
public void clientSetname(final byte[] name) { public void clientSetname(final byte[] name) {
sendCommand(CLIENT, Keyword.SETNAME.raw, name); sendCommand(CLIENT, Keyword.SETNAME.raw, name);
} }
public void time() { public void time() {
sendCommand(TIME); sendCommand(TIME);
} }
public void migrate(final byte[] host, final int port, final byte[] key, final int destinationDb, final int timeout) { public void migrate(final byte[] host, final int port, final byte[] key,
sendCommand(MIGRATE, host, toByteArray(port), key, toByteArray(destinationDb), toByteArray(timeout)); final int destinationDb, final int timeout) {
sendCommand(MIGRATE, host, toByteArray(port), key,
toByteArray(destinationDb), toByteArray(timeout));
} }
public void hincrByFloat(final byte[] key, final byte[] field, double increment) { public void hincrByFloat(final byte[] key, final byte[] field,
sendCommand(HINCRBYFLOAT, key, field, toByteArray(increment)); double increment) {
sendCommand(HINCRBYFLOAT, key, field, toByteArray(increment));
} }
public void scan(int cursor, final ScanParams params) { public void scan(int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
args.add(toByteArray(cursor)); args.add(toByteArray(cursor));
args.addAll(params.getParams()); args.addAll(params.getParams());
sendCommand(SCAN, args.toArray(new byte[args.size()][])); sendCommand(SCAN, args.toArray(new byte[args.size()][]));
} }
public void hscan(final byte[] key, int cursor, final ScanParams params) { public void hscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
args.add(key); args.add(key);
args.add(toByteArray(cursor)); args.add(toByteArray(cursor));
args.addAll(params.getParams()); args.addAll(params.getParams());
sendCommand(HSCAN, args.toArray(new byte[args.size()][])); sendCommand(HSCAN, args.toArray(new byte[args.size()][]));
} }
public void sscan(final byte[] key, int cursor, final ScanParams params) { public void sscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
args.add(key); args.add(key);
args.add(toByteArray(cursor)); args.add(toByteArray(cursor));
args.addAll(params.getParams()); args.addAll(params.getParams());
sendCommand(SSCAN, args.toArray(new byte[args.size()][])); sendCommand(SSCAN, args.toArray(new byte[args.size()][]));
} }
public void zscan(final byte[] key, int cursor, final ScanParams params) { public void zscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>(); final List<byte[]> args = new ArrayList<byte[]>();
args.add(key); args.add(key);
args.add(toByteArray(cursor)); args.add(toByteArray(cursor));
args.addAll(params.getParams()); args.addAll(params.getParams());
sendCommand(ZSCAN, args.toArray(new byte[args.size()][])); sendCommand(ZSCAN, args.toArray(new byte[args.size()][]));
} }
public void waitReplicas(int replicas, long timeout) { public void waitReplicas(int replicas, long timeout) {
sendCommand(WAIT, toByteArray(replicas), toByteArray(timeout)); sendCommand(WAIT, toByteArray(replicas), toByteArray(timeout));
} }
public void cluster(final byte[]... args) { public void cluster(final byte[]... args) {
sendCommand(CLUSTER, args); sendCommand(CLUSTER, args);
} }
public void asking() { public void asking() {
sendCommand(Command.ASKING); sendCommand(Command.ASKING);
} }
} }

484
src/main/java/redis/clients/jedis/BinaryJedis.java
View File

@@ -1,17 +1,25 @@
package redis.clients.jedis; package redis.clients.jedis;
import static redis.clients.jedis.Protocol.toByteArray;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION; import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.exceptions.JedisDataException; import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException; import redis.clients.jedis.exceptions.JedisException;
import redis.clients.util.JedisByteHashMap; import redis.clients.util.JedisByteHashMap;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
import java.net.URI; public class BinaryJedis implements BasicCommands, BinaryJedisCommands,
import java.util.*; MultiKeyBinaryCommands, AdvancedBinaryJedisCommands,
BinaryScriptingCommands {
import static redis.clients.jedis.Protocol.toByteArray;
public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKeyBinaryCommands, AdvancedBinaryJedisCommands, BinaryScriptingCommands {
protected Client client = null; protected Client client = null;
public BinaryJedis(final String host) { public BinaryJedis(final String host) {
@@ -75,18 +83,23 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
/** /**
* Set the string value as value of the key. The string can't be longer than * Set the string value as value of the key. The string can't be longer than
* 1073741824 bytes (1 GB). * 1073741824 bytes (1 GB).
*
* @param key * @param key
* @param value * @param value
* @param nxxx NX|XX, NX -- Only set the key if it does not already exist. * @param nxxx
* XX -- Only set the key if it already exist. * NX|XX, NX -- Only set the key if it does not already exist. XX
* @param expx EX|PX, expire time units: EX = seconds; PX = milliseconds * -- Only set the key if it already exist.
* @param time expire time in the units of {@param #expx} * @param expx
* EX|PX, expire time units: EX = seconds; PX = milliseconds
* @param time
* expire time in the units of {@param #expx}
* @return Status code reply * @return Status code reply
*/ */
public String set(final byte[] key, final byte[] value, final byte[] nxxx, final byte[] expx, final long time) { public String set(final byte[] key, final byte[] value, final byte[] nxxx,
checkIsInMulti(); final byte[] expx, final long time) {
client.set(key, value, nxxx, expx, time); checkIsInMulti();
return client.getStatusCodeReply(); client.set(key, value, nxxx, expx, time);
return client.getStatusCodeReply();
} }
/** /**
@@ -147,9 +160,9 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
} }
public Long del(final byte[] key) { public Long del(final byte[] key) {
checkIsInMulti(); checkIsInMulti();
client.del(key); client.del(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
/** /**
@@ -1006,7 +1019,8 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
* @return Multi bulk reply, specifically a list of elements in the * @return Multi bulk reply, specifically a list of elements in the
* specified range. * specified range.
*/ */
public List<byte[]> lrange(final byte[] key, final long start, final long end) { public List<byte[]> lrange(final byte[] key, final long start,
final long end) {
checkIsInMulti(); checkIsInMulti();
client.lrange(key, start, end); client.lrange(key, start, end);
return client.getBinaryMultiBulkReply(); return client.getBinaryMultiBulkReply();
@@ -1468,11 +1482,11 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
client.srandmember(key); client.srandmember(key);
return client.getBinaryBulkReply(); return client.getBinaryBulkReply();
} }
public List<byte[]> srandmember(final byte[] key, final int count) { public List<byte[]> srandmember(final byte[] key, final int count) {
checkIsInMulti(); checkIsInMulti();
client.srandmember(key, count); client.srandmember(key, count);
return client.getBinaryMultiBulkReply(); return client.getBinaryMultiBulkReply();
} }
/** /**
@@ -1502,7 +1516,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long zadd(final byte[] key, final Map<Double, byte[]> scoreMembers) { public Long zadd(final byte[] key, final Map<byte[], Double> scoreMembers) {
checkIsInMulti(); checkIsInMulti();
client.zaddBinary(key, scoreMembers); client.zaddBinary(key, scoreMembers);
return client.getIntegerReply(); return client.getIntegerReply();
@@ -1685,19 +1699,15 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
public List<Object> multi(final TransactionBlock jedisTransaction) { public List<Object> multi(final TransactionBlock jedisTransaction) {
List<Object> results = null; List<Object> results = null;
jedisTransaction.setClient(client); jedisTransaction.setClient(client);
try { client.multi();
client.multi(); jedisTransaction.execute();
jedisTransaction.execute(); results = jedisTransaction.exec();
results = jedisTransaction.exec();
} catch (Exception ex) {
jedisTransaction.discard();
}
return results; return results;
} }
protected void checkIsInMulti() { protected void checkIsInMulti() {
if (client.isInMulti()) { if (client.isInMulti()) {
throw new JedisDataException( throw new JedisDataException(
"Cannot use Jedis when in Multi. Please use JedisTransaction instead."); "Cannot use Jedis when in Multi. Please use JedisTransaction instead.");
} }
} }
@@ -1710,6 +1720,11 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
client.disconnect(); client.disconnect();
} }
public void resetState() {
client.resetState();
client.getAll();
}
public String watch(final byte[]... keys) { public String watch(final byte[]... keys) {
client.watch(keys); client.watch(keys);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
@@ -2044,43 +2059,43 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
} }
public List<byte[]> blpop(byte[] arg) { public List<byte[]> blpop(byte[] arg) {
checkIsInMulti(); checkIsInMulti();
byte[][] args = new byte[1][]; byte[][] args = new byte[1][];
args[0] = arg; args[0] = arg;
client.blpop(args); client.blpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply(); final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<byte[]> brpop(byte[] arg) { public List<byte[]> brpop(byte[] arg) {
checkIsInMulti(); checkIsInMulti();
byte[][] args = new byte[1][]; byte[][] args = new byte[1][];
args[0] = arg; args[0] = arg;
client.brpop(args); client.brpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply(); final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<byte[]> blpop(byte[]... args) { public List<byte[]> blpop(byte[]... args) {
checkIsInMulti(); checkIsInMulti();
client.blpop(args); client.blpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply(); final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<byte[]> brpop(byte[]... args) { public List<byte[]> brpop(byte[]... args) {
checkIsInMulti(); checkIsInMulti();
client.brpop(args); client.brpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply(); final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
/** /**
@@ -2126,15 +2141,15 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
} }
public Long zcount(final byte[] key, final double min, final double max) { public Long zcount(final byte[] key, final double min, final double max) {
return zcount(key, toByteArray(min), toByteArray(max)); return zcount(key, toByteArray(min), toByteArray(max));
} }
public Long zcount(final byte[] key, final byte[] min, final byte[] max) { public Long zcount(final byte[] key, final byte[] min, final byte[] max) {
checkIsInMulti(); checkIsInMulti();
client.zcount(key, min, max); client.zcount(key, min, max);
return client.getIntegerReply(); return client.getIntegerReply();
} }
/** /**
* Return the all the elements in the sorted set at key with a score between * Return the all the elements in the sorted set at key with a score between
* min and max (including elements with score equal to min or max). * min and max (including elements with score equal to min or max).
@@ -2194,7 +2209,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
public Set<byte[]> zrangeByScore(final byte[] key, final double min, public Set<byte[]> zrangeByScore(final byte[] key, final double min,
final double max) { final double max) {
return zrangeByScore(key, toByteArray(min), toByteArray(max)); return zrangeByScore(key, toByteArray(min), toByteArray(max));
} }
public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min, public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min,
final byte[] max) { final byte[] max) {
@@ -2261,15 +2276,16 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
*/ */
public Set<byte[]> zrangeByScore(final byte[] key, final double min, public Set<byte[]> zrangeByScore(final byte[] key, final double min,
final double max, final int offset, final int count) { final double max, final int offset, final int count) {
return zrangeByScore(key, toByteArray(min),toByteArray(max),offset, count); return zrangeByScore(key, toByteArray(min), toByteArray(max), offset,
count);
} }
public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min, public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min,
final byte[] max, final int offset, final int count) { final byte[] max, final int offset, final int count) {
checkIsInMulti(); checkIsInMulti();
client.zrangeByScore(key, min, max, offset, count); client.zrangeByScore(key, min, max, offset, count);
return new LinkedHashSet<byte[]>(client.getBinaryMultiBulkReply()); return new LinkedHashSet<byte[]>(client.getBinaryMultiBulkReply());
} }
/** /**
* Return the all the elements in the sorted set at key with a score between * Return the all the elements in the sorted set at key with a score between
@@ -2331,14 +2347,14 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
final double min, final double max) { final double min, final double max) {
return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max)); return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
} }
public Set<Tuple> zrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrangeByScoreWithScores(final byte[] key,
final byte[] min, final byte[] max) { final byte[] min, final byte[] max) {
checkIsInMulti(); checkIsInMulti();
client.zrangeByScoreWithScores(key, min, max); client.zrangeByScoreWithScores(key, min, max);
Set<Tuple> set = getBinaryTupledSet(); Set<Tuple> set = getBinaryTupledSet();
return set; return set;
} }
/** /**
* Return the all the elements in the sorted set at key with a score between * Return the all the elements in the sorted set at key with a score between
@@ -2399,17 +2415,18 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
public Set<Tuple> zrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrangeByScoreWithScores(final byte[] key,
final double min, final double max, final int offset, final double min, final double max, final int offset,
final int count) { final int count) {
return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count); return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max),
offset, count);
} }
public Set<Tuple> zrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrangeByScoreWithScores(final byte[] key,
final byte[] min, final byte[] max, final int offset, final byte[] min, final byte[] max, final int offset,
final int count) { final int count) {
checkIsInMulti(); checkIsInMulti();
client.zrangeByScoreWithScores(key, min, max, offset, count); client.zrangeByScoreWithScores(key, min, max, offset, count);
Set<Tuple> set = getBinaryTupledSet(); Set<Tuple> set = getBinaryTupledSet();
return set; return set;
} }
private Set<Tuple> getBinaryTupledSet() { private Set<Tuple> getBinaryTupledSet() {
checkIsInMulti(); checkIsInMulti();
@@ -2437,29 +2454,32 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
public Set<byte[]> zrevrangeByScore(final byte[] key, final double max, public Set<byte[]> zrevrangeByScore(final byte[] key, final double max,
final double min, final int offset, final int count) { final double min, final int offset, final int count) {
return zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count); return zrevrangeByScore(key, toByteArray(max), toByteArray(min),
offset, count);
} }
public Set<byte[]> zrevrangeByScore(final byte[] key, final byte[] max, public Set<byte[]> zrevrangeByScore(final byte[] key, final byte[] max,
final byte[] min, final int offset, final int count) { final byte[] min, final int offset, final int count) {
checkIsInMulti(); checkIsInMulti();
client.zrevrangeByScore(key, max, min, offset, count); client.zrevrangeByScore(key, max, min, offset, count);
return new LinkedHashSet<byte[]>(client.getBinaryMultiBulkReply()); return new LinkedHashSet<byte[]>(client.getBinaryMultiBulkReply());
} }
public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key,
final double max, final double min) { final double max, final double min) {
return zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min)); return zrevrangeByScoreWithScores(key, toByteArray(max),
toByteArray(min));
} }
public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key,
final double max, final double min, final int offset, final double max, final double min, final int offset,
final int count) { final int count) {
return zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count); return zrevrangeByScoreWithScores(key, toByteArray(max),
toByteArray(min), offset, count);
} }
public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key,
final byte[] max, final byte[] min) { final byte[] max, final byte[] min) {
checkIsInMulti(); checkIsInMulti();
client.zrevrangeByScoreWithScores(key, max, min); client.zrevrangeByScoreWithScores(key, max, min);
Set<Tuple> set = getBinaryTupledSet(); Set<Tuple> set = getBinaryTupledSet();
@@ -2473,7 +2493,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
client.zrevrangeByScoreWithScores(key, max, min, offset, count); client.zrevrangeByScoreWithScores(key, max, min, offset, count);
Set<Tuple> set = getBinaryTupledSet(); Set<Tuple> set = getBinaryTupledSet();
return set; return set;
} }
/** /**
* Remove all elements in the sorted set at key with rank between start and * Remove all elements in the sorted set at key with rank between start and
@@ -2488,7 +2508,8 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
* operation * operation
* *
*/ */
public Long zremrangeByRank(final byte[] key, final long start, final long end) { public Long zremrangeByRank(final byte[] key, final long start,
final long end) {
checkIsInMulti(); checkIsInMulti();
client.zremrangeByRank(key, start, end); client.zremrangeByRank(key, start, end);
return client.getIntegerReply(); return client.getIntegerReply();
@@ -2512,13 +2533,13 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
final double end) { final double end) {
return zremrangeByScore(key, toByteArray(start), toByteArray(end)); return zremrangeByScore(key, toByteArray(start), toByteArray(end));
} }
public Long zremrangeByScore(final byte[] key, final byte[] start, public Long zremrangeByScore(final byte[] key, final byte[] start,
final byte[] end) { final byte[] end) {
checkIsInMulti(); checkIsInMulti();
client.zremrangeByScore(key, start, end); client.zremrangeByScore(key, start, end);
return client.getIntegerReply(); return client.getIntegerReply();
} }
/** /**
* Creates a union or intersection of N sorted sets given by keys k1 through * Creates a union or intersection of N sorted sets given by keys k1 through
@@ -2842,7 +2863,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
client.info(); client.info();
return client.getBulkReply(); return client.getBulkReply();
} }
public String info(final String section) { public String info(final String section) {
client.info(section); client.info(section);
return client.getBulkReply(); return client.getBulkReply();
@@ -3078,8 +3099,8 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
} }
public Boolean setbit(byte[] key, long offset, byte[] value) { public Boolean setbit(byte[] key, long offset, byte[] value) {
client.setbit(key, offset, value); client.setbit(key, offset, value);
return client.getIntegerReply() == 1; return client.getIntegerReply() == 1;
} }
/** /**
@@ -3159,44 +3180,44 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
} }
public Object eval(byte[] script, int keyCount, byte[]... params) { public Object eval(byte[] script, int keyCount, byte[]... params) {
client.setTimeoutInfinite(); client.setTimeoutInfinite();
client.eval(script, SafeEncoder.encode(Integer.toString(keyCount)), params); client.eval(script, SafeEncoder.encode(Integer.toString(keyCount)),
return client.getOne(); params);
return client.getOne();
} }
public Object eval(byte[] script) { public Object eval(byte[] script) {
client.setTimeoutInfinite(); client.setTimeoutInfinite();
client.eval(script, 0); client.eval(script, 0);
return client.getOne(); return client.getOne();
} }
public Object evalsha(byte[] sha1) { public Object evalsha(byte[] sha1) {
client.setTimeoutInfinite(); client.setTimeoutInfinite();
client.evalsha(sha1, 0); client.evalsha(sha1, 0);
return client.getOne(); return client.getOne();
} }
public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
int keyCount = keys == null ? 0 : keys.size(); public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
int argCount = args == null ? 0 : args.size();
byte[][] params = new byte[keyCount + argCount][]; int keyCount = keys == null ? 0 : keys.size();
int argCount = args == null ? 0 : args.size();
for (int i = 0; i < keyCount; i++) byte[][] params = new byte[keyCount + argCount][];
params[i] = keys.get(i);
for (int i = 0; i < argCount; i++) for (int i = 0; i < keyCount; i++)
params[keyCount + i] = args.get(i); params[i] = keys.get(i);
for (int i = 0; i < argCount; i++)
params[keyCount + i] = args.get(i);
return evalsha(sha1, keyCount, params); return evalsha(sha1, keyCount, params);
} }
public Object evalsha(byte[] sha1, int keyCount, byte[]... params) { public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
client.setTimeoutInfinite(); client.setTimeoutInfinite();
client.evalsha(sha1, keyCount, params); client.evalsha(sha1, keyCount, params);
return client.getOne(); return client.getOne();
} }
public String scriptFlush() { public String scriptFlush() {
@@ -3206,7 +3227,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
public List<Long> scriptExists(byte[]... sha1) { public List<Long> scriptExists(byte[]... sha1) {
client.scriptExists(sha1); client.scriptExists(sha1);
return client.getIntegerMultiBulkReply(); return client.getIntegerMultiBulkReply();
} }
public byte[] scriptLoad(byte[] script) { public byte[] scriptLoad(byte[] script) {
@@ -3238,133 +3259,138 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
client.slowlogGet(entries); client.slowlogGet(entries);
return client.getBinaryMultiBulkReply(); return client.getBinaryMultiBulkReply();
} }
public Long objectRefcount(byte[] key) {
client.objectRefcount(key);
return client.getIntegerReply();
}
public byte[] objectEncoding(byte[] key) {
client.objectEncoding(key);
return client.getBinaryBulkReply();
}
public Long objectIdletime(byte[] key) { public Long objectRefcount(byte[] key) {
client.objectIdletime(key); client.objectRefcount(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public byte[] objectEncoding(byte[] key) {
client.objectEncoding(key);
return client.getBinaryBulkReply();
}
public Long objectIdletime(byte[] key) {
client.objectIdletime(key);
return client.getIntegerReply();
}
public Long bitcount(final byte[] key) { public Long bitcount(final byte[] key) {
client.bitcount(key); client.bitcount(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long bitcount(final byte[] key, long start, long end) { public Long bitcount(final byte[] key, long start, long end) {
client.bitcount(key, start, end); client.bitcount(key, start, end);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys) { public Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys) {
client.bitop(op, destKey, srcKeys); client.bitop(op, destKey, srcKeys);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public byte[] dump(final byte[] key) { public byte[] dump(final byte[] key) {
checkIsInMulti(); checkIsInMulti();
client.dump(key); client.dump(key);
return client.getBinaryBulkReply(); return client.getBinaryBulkReply();
} }
public String restore(final byte[] key, final int ttl, final byte[] serializedValue) { public String restore(final byte[] key, final int ttl,
checkIsInMulti(); final byte[] serializedValue) {
client.restore(key, ttl, serializedValue); checkIsInMulti();
return client.getStatusCodeReply(); client.restore(key, ttl, serializedValue);
return client.getStatusCodeReply();
} }
public Long pexpire(final byte[] key, final int milliseconds) { public Long pexpire(final byte[] key, final int milliseconds) {
checkIsInMulti(); checkIsInMulti();
client.pexpire(key, milliseconds); client.pexpire(key, milliseconds);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long pexpireAt(final byte[] key, final long millisecondsTimestamp) { public Long pexpireAt(final byte[] key, final long millisecondsTimestamp) {
checkIsInMulti(); checkIsInMulti();
client.pexpireAt(key, millisecondsTimestamp); client.pexpireAt(key, millisecondsTimestamp);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long pttl(final byte[] key) { public Long pttl(final byte[] key) {
checkIsInMulti(); checkIsInMulti();
client.pttl(key); client.pttl(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Double incrByFloat(final byte[] key, final double increment) { public Double incrByFloat(final byte[] key, final double increment) {
checkIsInMulti(); checkIsInMulti();
client.incrByFloat(key, increment); client.incrByFloat(key, increment);
String relpy = client.getBulkReply(); String relpy = client.getBulkReply();
return (relpy != null ? new Double(relpy) : null); return (relpy != null ? new Double(relpy) : null);
} }
public String psetex(final byte[] key, final int milliseconds, final byte[] value) { public String psetex(final byte[] key, final int milliseconds,
checkIsInMulti(); final byte[] value) {
client.psetex(key, milliseconds, value); checkIsInMulti();
return client.getStatusCodeReply(); client.psetex(key, milliseconds, value);
return client.getStatusCodeReply();
} }
public String set(final byte[] key, final byte[] value, final byte[] nxxx) { public String set(final byte[] key, final byte[] value, final byte[] nxxx) {
checkIsInMulti(); checkIsInMulti();
client.set(key, value, nxxx); client.set(key, value, nxxx);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String set(final byte[] key, final byte[] value, final byte[] nxxx, final byte[] expx, final int time) { public String set(final byte[] key, final byte[] value, final byte[] nxxx,
checkIsInMulti(); final byte[] expx, final int time) {
client.set(key, value, nxxx, expx, time); checkIsInMulti();
return client.getStatusCodeReply(); client.set(key, value, nxxx, expx, time);
return client.getStatusCodeReply();
} }
public String clientKill(final byte[] client) { public String clientKill(final byte[] client) {
checkIsInMulti(); checkIsInMulti();
this.client.clientKill(client); this.client.clientKill(client);
return this.client.getStatusCodeReply(); return this.client.getStatusCodeReply();
} }
public String clientGetname() { public String clientGetname() {
checkIsInMulti(); checkIsInMulti();
client.clientGetname(); client.clientGetname();
return client.getBulkReply(); return client.getBulkReply();
} }
public String clientList() { public String clientList() {
checkIsInMulti(); checkIsInMulti();
client.clientList(); client.clientList();
return client.getBulkReply(); return client.getBulkReply();
} }
public String clientSetname(final byte[] name) { public String clientSetname(final byte[] name) {
checkIsInMulti(); checkIsInMulti();
client.clientSetname(name); client.clientSetname(name);
return client.getBulkReply(); return client.getBulkReply();
} }
public List<String> time() { public List<String> time() {
checkIsInMulti(); checkIsInMulti();
client.time(); client.time();
return client.getMultiBulkReply(); return client.getMultiBulkReply();
} }
public String migrate(final byte[] host, final int port, final byte[] key, final int destinationDb, final int timeout) { public String migrate(final byte[] host, final int port, final byte[] key,
checkIsInMulti(); final int destinationDb, final int timeout) {
client.migrate(host, port, key, destinationDb, timeout); checkIsInMulti();
return client.getStatusCodeReply(); client.migrate(host, port, key, destinationDb, timeout);
return client.getStatusCodeReply();
} }
public Double hincrByFloat(final byte[] key, final byte[] field, double increment) { public Double hincrByFloat(final byte[] key, final byte[] field,
checkIsInMulti(); double increment) {
client.hincrByFloat(key, field, increment); checkIsInMulti();
String relpy = client.getBulkReply(); client.hincrByFloat(key, field, increment);
return (relpy != null ? new Double(relpy) : null); String relpy = client.getBulkReply();
return (relpy != null ? new Double(relpy) : null);
} }
/** /**
@@ -3375,9 +3401,9 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
* so I had to change the name of the method. Sorry :S * so I had to change the name of the method. Sorry :S
*/ */
public Long waitReplicas(int replicas, long timeout) { public Long waitReplicas(int replicas, long timeout) {
checkIsInMulti(); checkIsInMulti();
client.waitReplicas(replicas, timeout); client.waitReplicas(replicas, timeout);
return client.getIntegerReply(); return client.getIntegerReply();
} }
} }

2
src/main/java/redis/clients/jedis/BinaryJedisCommands.java
View File

@@ -115,7 +115,7 @@ public interface BinaryJedisCommands {
Long zadd(byte[] key, double score, byte[] member); Long zadd(byte[] key, double score, byte[] member);
Long zadd(byte[] key, Map<Double, byte[]> scoreMembers); Long zadd(byte[] key, Map<byte[], Double> scoreMembers);
Set<byte[]> zrange(byte[] key, long start, long end); Set<byte[]> zrange(byte[] key, long start, long end);

114
src/main/java/redis/clients/jedis/BinaryJedisPubSub.java
View File

@@ -19,7 +19,7 @@ public abstract class BinaryJedisPubSub {
public abstract void onMessage(byte[] channel, byte[] message); public abstract void onMessage(byte[] channel, byte[] message);
public abstract void onPMessage(byte[] pattern, byte[] channel, public abstract void onPMessage(byte[] pattern, byte[] channel,
byte[] message); byte[] message);
public abstract void onSubscribe(byte[] channel, int subscribedChannels); public abstract void onSubscribe(byte[] channel, int subscribedChannels);
@@ -30,91 +30,91 @@ public abstract class BinaryJedisPubSub {
public abstract void onPSubscribe(byte[] pattern, int subscribedChannels); public abstract void onPSubscribe(byte[] pattern, int subscribedChannels);
public void unsubscribe() { public void unsubscribe() {
client.unsubscribe(); client.unsubscribe();
client.flush(); client.flush();
} }
public void unsubscribe(byte[]... channels) { public void unsubscribe(byte[]... channels) {
client.unsubscribe(channels); client.unsubscribe(channels);
client.flush(); client.flush();
} }
public void subscribe(byte[]... channels) { public void subscribe(byte[]... channels) {
client.subscribe(channels); client.subscribe(channels);
client.flush(); client.flush();
} }
public void psubscribe(byte[]... patterns) { public void psubscribe(byte[]... patterns) {
client.psubscribe(patterns); client.psubscribe(patterns);
client.flush(); client.flush();
} }
public void punsubscribe() { public void punsubscribe() {
client.punsubscribe(); client.punsubscribe();
client.flush(); client.flush();
} }
public void punsubscribe(byte[]... patterns) { public void punsubscribe(byte[]... patterns) {
client.punsubscribe(patterns); client.punsubscribe(patterns);
client.flush(); client.flush();
} }
public boolean isSubscribed() { public boolean isSubscribed() {
return subscribedChannels > 0; return subscribedChannels > 0;
} }
public void proceedWithPatterns(Client client, byte[]... patterns) { public void proceedWithPatterns(Client client, byte[]... patterns) {
this.client = client; this.client = client;
client.psubscribe(patterns); client.psubscribe(patterns);
process(client); process(client);
} }
public void proceed(Client client, byte[]... channels) { public void proceed(Client client, byte[]... channels) {
this.client = client; this.client = client;
client.subscribe(channels); client.subscribe(channels);
process(client); process(client);
} }
private void process(Client client) { private void process(Client client) {
do { do {
List<Object> reply = client.getObjectMultiBulkReply(); List<Object> reply = client.getObjectMultiBulkReply();
final Object firstObj = reply.get(0); final Object firstObj = reply.get(0);
if (!(firstObj instanceof byte[])) { if (!(firstObj instanceof byte[])) {
throw new JedisException("Unknown message type: " + firstObj); throw new JedisException("Unknown message type: " + firstObj);
} }
final byte[] resp = (byte[]) firstObj; final byte[] resp = (byte[]) firstObj;
if (Arrays.equals(SUBSCRIBE.raw, resp)) { if (Arrays.equals(SUBSCRIBE.raw, resp)) {
subscribedChannels = ((Long) reply.get(2)).intValue(); subscribedChannels = ((Long) reply.get(2)).intValue();
final byte[] bchannel = (byte[]) reply.get(1); final byte[] bchannel = (byte[]) reply.get(1);
onSubscribe(bchannel, subscribedChannels); onSubscribe(bchannel, subscribedChannels);
} else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) { } else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) {
subscribedChannels = ((Long) reply.get(2)).intValue(); subscribedChannels = ((Long) reply.get(2)).intValue();
final byte[] bchannel = (byte[]) reply.get(1); final byte[] bchannel = (byte[]) reply.get(1);
onUnsubscribe(bchannel, subscribedChannels); onUnsubscribe(bchannel, subscribedChannels);
} else if (Arrays.equals(MESSAGE.raw, resp)) { } else if (Arrays.equals(MESSAGE.raw, resp)) {
final byte[] bchannel = (byte[]) reply.get(1); final byte[] bchannel = (byte[]) reply.get(1);
final byte[] bmesg = (byte[]) reply.get(2); final byte[] bmesg = (byte[]) reply.get(2);
onMessage(bchannel, bmesg); onMessage(bchannel, bmesg);
} else if (Arrays.equals(PMESSAGE.raw, resp)) { } else if (Arrays.equals(PMESSAGE.raw, resp)) {
final byte[] bpattern = (byte[]) reply.get(1); final byte[] bpattern = (byte[]) reply.get(1);
final byte[] bchannel = (byte[]) reply.get(2); final byte[] bchannel = (byte[]) reply.get(2);
final byte[] bmesg = (byte[]) reply.get(3); final byte[] bmesg = (byte[]) reply.get(3);
onPMessage(bpattern, bchannel, bmesg); onPMessage(bpattern, bchannel, bmesg);
} else if (Arrays.equals(PSUBSCRIBE.raw, resp)) { } else if (Arrays.equals(PSUBSCRIBE.raw, resp)) {
subscribedChannels = ((Long) reply.get(2)).intValue(); subscribedChannels = ((Long) reply.get(2)).intValue();
final byte[] bpattern = (byte[]) reply.get(1); final byte[] bpattern = (byte[]) reply.get(1);
onPSubscribe(bpattern, subscribedChannels); onPSubscribe(bpattern, subscribedChannels);
} else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) { } else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) {
subscribedChannels = ((Long) reply.get(2)).intValue(); subscribedChannels = ((Long) reply.get(2)).intValue();
final byte[] bpattern = (byte[]) reply.get(1); final byte[] bpattern = (byte[]) reply.get(1);
onPUnsubscribe(bpattern, subscribedChannels); onPUnsubscribe(bpattern, subscribedChannels);
} else { } else {
throw new JedisException("Unknown message type: " + firstObj); throw new JedisException("Unknown message type: " + firstObj);
} }
} while (isSubscribed()); } while (isSubscribed());
} }
public int getSubscribedChannels() { public int getSubscribedChannels() {
return subscribedChannels; return subscribedChannels;
} }
} }

60
src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
View File

@@ -67,7 +67,7 @@ public interface BinaryRedisPipeline {
Response<byte[]> lindex(byte[] key, long index); Response<byte[]> lindex(byte[] key, long index);
Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where, Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
byte[] pivot, byte[] value); byte[] pivot, byte[] value);
Response<Long> llen(byte[] key); Response<Long> llen(byte[] key);
@@ -117,8 +117,7 @@ public interface BinaryRedisPipeline {
Response<List<byte[]>> sort(byte[] key); Response<List<byte[]>> sort(byte[] key);
Response<List<byte[]>> sort(byte[] key, Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters);
SortingParams sortingParameters);
Response<byte[]> spop(byte[] key); Response<byte[]> spop(byte[] key);
@@ -144,53 +143,49 @@ public interface BinaryRedisPipeline {
Response<Set<byte[]>> zrange(byte[] key, long start, long end); Response<Set<byte[]>> zrange(byte[] key, long start, long end);
Response<Set<byte[]>> zrangeByScore(byte[] key, double min, Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max);
double max);
Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max);
byte[] max);
Response<Set<byte[]>> zrangeByScore(byte[] key, double min, Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max,
double max, int offset, int count); int offset, int count);
Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max,
byte[] max, int offset, int count); int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max); double max);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max); byte[] max);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count); double max, int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max, int offset, int count); byte[] max, int offset, int count);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min);
double min);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min);
byte[] min);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min,
double min, int offset, int count); int offset, int count);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min,
byte[] min, int offset, int count); int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max,
double max, double min); double min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max,
byte[] max, byte[] min); byte[] min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max,
double max, double min, int offset, int count); double min, int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max,
byte[] max, byte[] min, int offset, int count); byte[] min, int offset, int count);
Response<Set<Tuple>> zrangeWithScores(byte[] key, long start, long end); Response<Set<Tuple>> zrangeWithScores(byte[] key, long start, long end);
@@ -206,8 +201,7 @@ public interface BinaryRedisPipeline {
Response<Set<byte[]>> zrevrange(byte[] key, long start, long end); Response<Set<byte[]>> zrevrange(byte[] key, long start, long end);
Response<Set<Tuple>> zrevrangeWithScores(byte[] key, long start, Response<Set<Tuple>> zrevrangeWithScores(byte[] key, long start, long end);
long end);
Response<Long> zrevrank(byte[] key, byte[] member); Response<Long> zrevrank(byte[] key, byte[] member);

3
src/main/java/redis/clients/jedis/BinaryScriptingCommands.java
View File

@@ -1,6 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
public interface BinaryScriptingCommands { public interface BinaryScriptingCommands {
@@ -8,7 +7,7 @@ public interface BinaryScriptingCommands {
Object eval(byte[] script, byte[] keyCount, byte[]... params); Object eval(byte[] script, byte[] keyCount, byte[]... params);
Object eval(byte[] script, int keyCount, byte[]... params); Object eval(byte[] script, int keyCount, byte[]... params);
Object eval(byte[] script, List<byte[]> keys, List<byte[]> args); Object eval(byte[] script, List<byte[]> keys, List<byte[]> args);
Object eval(byte[] script); Object eval(byte[] script);

2
src/main/java/redis/clients/jedis/BinaryShardedJedis.java
View File

@@ -295,7 +295,7 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.zadd(key, score, member); return j.zadd(key, score, member);
} }
public Long zadd(byte[] key, Map<Double, byte[]> scoreMembers) { public Long zadd(byte[] key, Map<byte[], Double> scoreMembers) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zadd(key, scoreMembers); return j.zadd(key, scoreMembers);
} }

5
src/main/java/redis/clients/jedis/BitOP.java
View File

@@ -1,8 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
public enum BitOP { public enum BitOP {
AND, AND, OR, XOR, NOT;
OR,
XOR,
NOT;
} }

370
src/main/java/redis/clients/jedis/BuilderFactory.java
View File

@@ -1,249 +1,257 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
import java.util.*;
public class BuilderFactory { public class BuilderFactory {
public static final Builder<Double> DOUBLE = new Builder<Double>() { public static final Builder<Double> DOUBLE = new Builder<Double>() {
public Double build(Object data) { public Double build(Object data) {
String asString = STRING.build(data); String asString = STRING.build(data);
return asString == null ? null : Double.valueOf(asString); return asString == null ? null : Double.valueOf(asString);
} }
public String toString() { public String toString() {
return "double"; return "double";
} }
}; };
public static final Builder<Boolean> BOOLEAN = new Builder<Boolean>() { public static final Builder<Boolean> BOOLEAN = new Builder<Boolean>() {
public Boolean build(Object data) { public Boolean build(Object data) {
return ((Long) data) == 1; return ((Long) data) == 1;
} }
public String toString() { public String toString() {
return "boolean"; return "boolean";
} }
}; };
public static final Builder<byte[]> BYTE_ARRAY = new Builder<byte[]>() { public static final Builder<byte[]> BYTE_ARRAY = new Builder<byte[]>() {
public byte[] build(Object data) { public byte[] build(Object data) {
return ((byte[]) data); // deleted == 1 return ((byte[]) data); // deleted == 1
} }
public String toString() { public String toString() {
return "byte[]"; return "byte[]";
} }
}; };
public static final Builder<Long> LONG = new Builder<Long>() { public static final Builder<Long> LONG = new Builder<Long>() {
public Long build(Object data) { public Long build(Object data) {
return (Long) data; return (Long) data;
} }
public String toString() { public String toString() {
return "long"; return "long";
} }
}; };
public static final Builder<String> STRING = new Builder<String>() { public static final Builder<String> STRING = new Builder<String>() {
public String build(Object data) { public String build(Object data) {
return data == null ? null : SafeEncoder.encode((byte[]) data); return data == null ? null : SafeEncoder.encode((byte[]) data);
} }
public String toString() { public String toString() {
return "string"; return "string";
} }
}; };
public static final Builder<List<String>> STRING_LIST = new Builder<List<String>>() { public static final Builder<List<String>> STRING_LIST = new Builder<List<String>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<String> build(Object data) { public List<String> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final ArrayList<String> result = new ArrayList<String>(l.size()); final ArrayList<String> result = new ArrayList<String>(l.size());
for (final byte[] barray : l) { for (final byte[] barray : l) {
if (barray == null) { if (barray == null) {
result.add(null); result.add(null);
} else { } else {
result.add(SafeEncoder.encode(barray)); result.add(SafeEncoder.encode(barray));
} }
} }
return result; return result;
} }
public String toString() { public String toString() {
return "List<String>"; return "List<String>";
} }
}; };
public static final Builder<Map<String, String>> STRING_MAP = new Builder<Map<String, String>>() { public static final Builder<Map<String, String>> STRING_MAP = new Builder<Map<String, String>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Map<String, String> build(Object data) { public Map<String, String> build(Object data) {
final List<byte[]> flatHash = (List<byte[]>) data; final List<byte[]> flatHash = (List<byte[]>) data;
final Map<String, String> hash = new HashMap<String, String>(); final Map<String, String> hash = new HashMap<String, String>();
final Iterator<byte[]> iterator = flatHash.iterator(); final Iterator<byte[]> iterator = flatHash.iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
hash.put(SafeEncoder.encode(iterator.next()), SafeEncoder hash.put(SafeEncoder.encode(iterator.next()),
.encode(iterator.next())); SafeEncoder.encode(iterator.next()));
} }
return hash; return hash;
} }
public String toString() { public String toString() {
return "Map<String, String>"; return "Map<String, String>";
} }
}; };
public static final Builder<Set<String>> STRING_SET = new Builder<Set<String>>() { public static final Builder<Set<String>> STRING_SET = new Builder<Set<String>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Set<String> build(Object data) { public Set<String> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final Set<String> result = new HashSet<String>(l.size()); final Set<String> result = new HashSet<String>(l.size());
for (final byte[] barray : l) { for (final byte[] barray : l) {
if (barray == null) { if (barray == null) {
result.add(null); result.add(null);
} else { } else {
result.add(SafeEncoder.encode(barray)); result.add(SafeEncoder.encode(barray));
} }
} }
return result; return result;
} }
public String toString() { public String toString() {
return "Set<String>"; return "Set<String>";
} }
}; };
public static final Builder<List<byte[]>> BYTE_ARRAY_LIST = new Builder<List<byte[]>>() { public static final Builder<List<byte[]>> BYTE_ARRAY_LIST = new Builder<List<byte[]>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<byte[]> build(Object data) { public List<byte[]> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
return l; return l;
} }
public String toString() { public String toString() {
return "List<byte[]>"; return "List<byte[]>";
} }
}; };
public static final Builder<Set<byte[]>> BYTE_ARRAY_ZSET = new Builder<Set<byte[]>>() { public static final Builder<Set<byte[]>> BYTE_ARRAY_ZSET = new Builder<Set<byte[]>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Set<byte[]> build(Object data) { public Set<byte[]> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final Set<byte[]> result = new LinkedHashSet<byte[]>(l); final Set<byte[]> result = new LinkedHashSet<byte[]>(l);
for (final byte[] barray : l) { for (final byte[] barray : l) {
if (barray == null) { if (barray == null) {
result.add(null); result.add(null);
} else { } else {
result.add(barray); result.add(barray);
} }
} }
return result; return result;
} }
public String toString() { public String toString() {
return "ZSet<byte[]>"; return "ZSet<byte[]>";
} }
}; };
public static final Builder<Map<byte[], byte[]>> BYTE_ARRAY_MAP = new Builder<Map<byte[], byte[]>>() { public static final Builder<Map<byte[], byte[]>> BYTE_ARRAY_MAP = new Builder<Map<byte[], byte[]>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Map<byte[], byte[]> build(Object data) { public Map<byte[], byte[]> build(Object data) {
final List<byte[]> flatHash = (List<byte[]>) data; final List<byte[]> flatHash = (List<byte[]>) data;
final Map<byte[], byte[]> hash = new HashMap<byte[], byte[]>(); final Map<byte[], byte[]> hash = new HashMap<byte[], byte[]>();
final Iterator<byte[]> iterator = flatHash.iterator(); final Iterator<byte[]> iterator = flatHash.iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
hash.put(iterator.next(), iterator.next()); hash.put(iterator.next(), iterator.next());
} }
return hash; return hash;
} }
public String toString() { public String toString() {
return "Map<byte[], byte[]>"; return "Map<byte[], byte[]>";
} }
}; };
public static final Builder<Set<String>> STRING_ZSET = new Builder<Set<String>>() { public static final Builder<Set<String>> STRING_ZSET = new Builder<Set<String>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Set<String> build(Object data) { public Set<String> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final Set<String> result = new LinkedHashSet<String>(l.size()); final Set<String> result = new LinkedHashSet<String>(l.size());
for (final byte[] barray : l) { for (final byte[] barray : l) {
if (barray == null) { if (barray == null) {
result.add(null); result.add(null);
} else { } else {
result.add(SafeEncoder.encode(barray)); result.add(SafeEncoder.encode(barray));
} }
} }
return result; return result;
} }
public String toString() { public String toString() {
return "ZSet<String>"; return "ZSet<String>";
} }
}; };
public static final Builder<Set<Tuple>> TUPLE_ZSET = new Builder<Set<Tuple>>() { public static final Builder<Set<Tuple>> TUPLE_ZSET = new Builder<Set<Tuple>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Set<Tuple> build(Object data) { public Set<Tuple> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final Set<Tuple> result = new LinkedHashSet<Tuple>(l.size()); final Set<Tuple> result = new LinkedHashSet<Tuple>(l.size());
Iterator<byte[]> iterator = l.iterator(); Iterator<byte[]> iterator = l.iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
result.add(new Tuple(SafeEncoder.encode(iterator.next()), result.add(new Tuple(SafeEncoder.encode(iterator.next()),
Double.valueOf(SafeEncoder.encode(iterator.next())))); Double.valueOf(SafeEncoder.encode(iterator.next()))));
} }
return result; return result;
} }
public String toString() { public String toString() {
return "ZSet<Tuple>"; return "ZSet<Tuple>";
} }
}; };
public static final Builder<Set<Tuple>> TUPLE_ZSET_BINARY = new Builder<Set<Tuple>>() { public static final Builder<Set<Tuple>> TUPLE_ZSET_BINARY = new Builder<Set<Tuple>>() {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Set<Tuple> build(Object data) { public Set<Tuple> build(Object data) {
if (null == data) { if (null == data) {
return null; return null;
} }
List<byte[]> l = (List<byte[]>) data; List<byte[]> l = (List<byte[]>) data;
final Set<Tuple> result = new LinkedHashSet<Tuple>(l.size()); final Set<Tuple> result = new LinkedHashSet<Tuple>(l.size());
Iterator<byte[]> iterator = l.iterator(); Iterator<byte[]> iterator = l.iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
result.add(new Tuple(iterator.next(), Double result.add(new Tuple(iterator.next(), Double
.valueOf(SafeEncoder.encode(iterator.next())))); .valueOf(SafeEncoder.encode(iterator.next()))));
} }
return result; return result;
} }
public String toString() { public String toString() {
return "ZSet<Tuple>"; return "ZSet<Tuple>";
} }
}; };
} }

222
src/main/java/redis/clients/jedis/Client.java
View File

@@ -1,6 +1,6 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.util.SafeEncoder; import static redis.clients.jedis.Protocol.toByteArray;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
@@ -8,8 +8,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import static redis.clients.jedis.Protocol.toByteArray; import redis.clients.util.SafeEncoder;
import static redis.clients.jedis.Protocol.Command.HSCAN;
public class Client extends BinaryClient implements Commands { public class Client extends BinaryClient implements Commands {
public Client(final String host) { public Client(final String host) {
@@ -24,8 +23,10 @@ public class Client extends BinaryClient implements Commands {
set(SafeEncoder.encode(key), SafeEncoder.encode(value)); set(SafeEncoder.encode(key), SafeEncoder.encode(value));
} }
public void set(final String key, final String value, final String nxxx, final String expx, final long time) { public void set(final String key, final String value, final String nxxx,
set(SafeEncoder.encode(key), SafeEncoder.encode(value), SafeEncoder.encode(nxxx), SafeEncoder.encode(expx), time); final String expx, final long time) {
set(SafeEncoder.encode(key), SafeEncoder.encode(value),
SafeEncoder.encode(nxxx), SafeEncoder.encode(expx), time);
} }
public void get(final String key) { public void get(final String key) {
@@ -392,14 +393,14 @@ public class Client extends BinaryClient implements Commands {
} }
blpop(bargs); blpop(bargs);
} }
public void blpop(final int timeout, final String... keys) { public void blpop(final int timeout, final String... keys) {
List<String> args = new ArrayList<String>(); List<String> args = new ArrayList<String>();
for (String arg : keys) { for (String arg : keys) {
args.add(arg); args.add(arg);
} }
args.add(String.valueOf(timeout)); args.add(String.valueOf(timeout));
blpop(args.toArray(new String[args.size()])); blpop(args.toArray(new String[args.size()]));
} }
public void sort(final String key, final SortingParams sortingParameters, public void sort(final String key, final SortingParams sortingParameters,
@@ -419,14 +420,14 @@ public class Client extends BinaryClient implements Commands {
} }
brpop(bargs); brpop(bargs);
} }
public void brpop(final int timeout, final String... keys) { public void brpop(final int timeout, final String... keys) {
List<String> args = new ArrayList<String>(); List<String> args = new ArrayList<String>();
for (String arg : keys) { for (String arg : keys) {
args.add(arg); args.add(arg);
} }
args.add(String.valueOf(timeout)); args.add(String.valueOf(timeout));
brpop(args.toArray(new String[args.size()])); brpop(args.toArray(new String[args.size()]));
} }
public void zcount(final String key, final double min, final double max) { public void zcount(final String key, final double min, final double max) {
@@ -621,7 +622,7 @@ public class Client extends BinaryClient implements Commands {
} }
public void setbit(final String key, final long offset, final String value) { public void setbit(final String key, final long offset, final String value) {
setbit(SafeEncoder.encode(key), offset, SafeEncoder.encode(value)); setbit(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
} }
public void getbit(String key, long offset) { public void getbit(String key, long offset) {
@@ -671,6 +672,18 @@ public class Client extends BinaryClient implements Commands {
} }
subscribe(cs); subscribe(cs);
} }
public void pubsubChannels(String pattern) {
pubsub(Protocol.PUBSUB_CHANNELS, pattern);
}
public void pubsubNumPat() {
pubsub(Protocol.PUBSUB_NUM_PAT);
}
public void pubsubNumSub(String... channels) {
pubsub(Protocol.PUBSUB_NUMSUB, channels);
}
public void configSet(String parameter, String value) { public void configSet(String parameter, String value) {
configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value)); configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value));
@@ -710,12 +723,14 @@ public class Client extends BinaryClient implements Commands {
scriptLoad(SafeEncoder.encode(script)); scriptLoad(SafeEncoder.encode(script));
} }
public void zadd(String key, Map<Double, String> scoreMembers) { public void zadd(String key, Map<String, Double> scoreMembers) {
HashMap<Double, byte[]> binaryScoreMembers = new HashMap<Double, byte[]>();
for (Map.Entry<Double, String> entry : scoreMembers.entrySet()) { HashMap<byte[], Double> binaryScoreMembers = new HashMap<byte[], Double>();
binaryScoreMembers.put(entry.getKey(),
SafeEncoder.encode(entry.getValue())); for (Map.Entry<String, Double> entry : scoreMembers.entrySet()) {
binaryScoreMembers.put(SafeEncoder.encode(entry.getKey()),
entry.getValue());
} }
zaddBinary(SafeEncoder.encode(key), binaryScoreMembers); zaddBinary(SafeEncoder.encode(key), binaryScoreMembers);
@@ -734,15 +749,15 @@ public class Client extends BinaryClient implements Commands {
} }
public void bitcount(final String key) { public void bitcount(final String key) {
bitcount(SafeEncoder.encode(key)); bitcount(SafeEncoder.encode(key));
} }
public void bitcount(final String key, long start, long end) { public void bitcount(final String key, long start, long end) {
bitcount(SafeEncoder.encode(key), start, end); bitcount(SafeEncoder.encode(key), start, end);
} }
public void bitop(BitOP op, final String destKey, String... srcKeys) { public void bitop(BitOP op, final String destKey, String... srcKeys) {
bitop(op, SafeEncoder.encode(destKey), getByteParams(srcKeys)); bitop(op, SafeEncoder.encode(destKey), getByteParams(srcKeys));
} }
public void sentinel(final String... args) { public void sentinel(final String... args) {
@@ -753,132 +768,153 @@ public class Client extends BinaryClient implements Commands {
sentinel(arg); sentinel(arg);
} }
public void dump(final String key) { public void dump(final String key) {
dump(SafeEncoder.encode(key)); dump(SafeEncoder.encode(key));
} }
public void restore(final String key, final int ttl, final byte[] serializedValue) { public void restore(final String key, final int ttl,
restore(SafeEncoder.encode(key), ttl, serializedValue); final byte[] serializedValue) {
restore(SafeEncoder.encode(key), ttl, serializedValue);
} }
public void pexpire(final String key, final int milliseconds) { public void pexpire(final String key, final int milliseconds) {
pexpire(SafeEncoder.encode(key), milliseconds); pexpire(SafeEncoder.encode(key), milliseconds);
} }
public void pexpireAt(final String key, final long millisecondsTimestamp) { public void pexpireAt(final String key, final long millisecondsTimestamp) {
pexpireAt(SafeEncoder.encode(key), millisecondsTimestamp); pexpireAt(SafeEncoder.encode(key), millisecondsTimestamp);
} }
public void pttl(final String key) { public void pttl(final String key) {
pttl(SafeEncoder.encode(key)); pttl(SafeEncoder.encode(key));
} }
public void incrByFloat(final String key, final double increment) { public void incrByFloat(final String key, final double increment) {
incrByFloat(SafeEncoder.encode(key), increment); incrByFloat(SafeEncoder.encode(key), increment);
} }
public void psetex(final String key, final int milliseconds, final String value) { public void psetex(final String key, final int milliseconds,
psetex(SafeEncoder.encode(key), milliseconds, SafeEncoder.encode(value)); final String value) {
psetex(SafeEncoder.encode(key), milliseconds, SafeEncoder.encode(value));
} }
public void set(final String key, final String value, final String nxxx) { public void set(final String key, final String value, final String nxxx) {
set(SafeEncoder.encode(key), SafeEncoder.encode(value), SafeEncoder.encode(nxxx)); set(SafeEncoder.encode(key), SafeEncoder.encode(value),
SafeEncoder.encode(nxxx));
} }
public void set(final String key, final String value, final String nxxx, final String expx, final int time) { public void set(final String key, final String value, final String nxxx,
set(SafeEncoder.encode(key), SafeEncoder.encode(value), SafeEncoder.encode(nxxx), SafeEncoder.encode(expx), time); final String expx, final int time) {
set(SafeEncoder.encode(key), SafeEncoder.encode(value),
SafeEncoder.encode(nxxx), SafeEncoder.encode(expx), time);
} }
public void srandmember(final String key, final int count) { public void srandmember(final String key, final int count) {
srandmember(SafeEncoder.encode(key), count); srandmember(SafeEncoder.encode(key), count);
} }
public void clientKill(final String client) { public void clientKill(final String client) {
clientKill(SafeEncoder.encode(client)); clientKill(SafeEncoder.encode(client));
} }
public void clientSetname(final String name) { public void clientSetname(final String name) {
clientSetname(SafeEncoder.encode(name)); clientSetname(SafeEncoder.encode(name));
} }
public void migrate(final String host, final int port, final String key, final int destinationDb, final int timeout) { public void migrate(final String host, final int port, final String key,
migrate(SafeEncoder.encode(host), port, SafeEncoder.encode(key), destinationDb, timeout); final int destinationDb, final int timeout) {
migrate(SafeEncoder.encode(host), port, SafeEncoder.encode(key),
destinationDb, timeout);
} }
public void hincrByFloat(final String key, final String field, double increment) { public void hincrByFloat(final String key, final String field,
hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field), increment); double increment) {
hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field),
increment);
} }
public void hscan(final String key, int cursor, final ScanParams params) { public void hscan(final String key, int cursor, final ScanParams params) {
hscan(SafeEncoder.encode(key), cursor, params); hscan(SafeEncoder.encode(key), cursor, params);
} }
public void sscan(final String key, int cursor, final ScanParams params) { public void sscan(final String key, int cursor, final ScanParams params) {
sscan(SafeEncoder.encode(key), cursor, params); sscan(SafeEncoder.encode(key), cursor, params);
} }
public void zscan(final String key, int cursor, final ScanParams params) { public void zscan(final String key, int cursor, final ScanParams params) {
zscan(SafeEncoder.encode(key), cursor, params); zscan(SafeEncoder.encode(key), cursor, params);
} }
public void cluster(final String subcommand, final int... args) { public void cluster(final String subcommand, final int... args) {
final byte[][] arg = new byte[args.length+1][]; final byte[][] arg = new byte[args.length + 1][];
for (int i = 1; i < arg.length; i++) { for (int i = 1; i < arg.length; i++) {
arg[i] = toByteArray(args[i-1]); arg[i] = toByteArray(args[i - 1]);
}
arg[0] = SafeEncoder.encode(subcommand);
cluster(arg);
}
public void cluster(final String subcommand, final String... args) {
final byte[][] arg = new byte[args.length+1][];
for (int i = 1; i < arg.length; i++) {
arg[i] = SafeEncoder.encode(args[i-1]);
} }
arg[0] = SafeEncoder.encode(subcommand); arg[0] = SafeEncoder.encode(subcommand);
cluster(arg); cluster(arg);
} }
public void pubsub(final String subcommand, final String... args) {
final byte[][] arg = new byte[args.length+1][];
for (int i = 1; i < arg.length; i++) {
arg[i] = SafeEncoder.encode(args[i-1]);
}
arg[0] = SafeEncoder.encode(subcommand);
pubsub(arg);
}
public void cluster(final String subcommand, final String... args) {
final byte[][] arg = new byte[args.length + 1][];
for (int i = 1; i < arg.length; i++) {
arg[i] = SafeEncoder.encode(args[i - 1]);
}
arg[0] = SafeEncoder.encode(subcommand);
cluster(arg);
}
public void cluster(final String subcommand) { public void cluster(final String subcommand) {
final byte[][] arg = new byte[1][]; final byte[][] arg = new byte[1][];
arg[0] = SafeEncoder.encode(subcommand); arg[0] = SafeEncoder.encode(subcommand);
cluster(arg); cluster(arg);
} }
public void clusterNodes() { public void clusterNodes() {
cluster(Protocol.CLUSTER_NODES); cluster(Protocol.CLUSTER_NODES);
} }
public void clusterMeet(final String ip, final int port) { public void clusterMeet(final String ip, final int port) {
cluster(Protocol.CLUSTER_MEET, ip, String.valueOf(port)); cluster(Protocol.CLUSTER_MEET, ip, String.valueOf(port));
} }
public void clusterAddSlots(final int ...slots) { public void clusterAddSlots(final int... slots) {
cluster(Protocol.CLUSTER_ADDSLOTS, slots); cluster(Protocol.CLUSTER_ADDSLOTS, slots);
} }
public void clusterDelSlots(final int ...slots) { public void clusterDelSlots(final int... slots) {
cluster(Protocol.CLUSTER_DELSLOTS, slots); cluster(Protocol.CLUSTER_DELSLOTS, slots);
} }
public void clusterInfo() { public void clusterInfo() {
cluster(Protocol.CLUSTER_INFO); cluster(Protocol.CLUSTER_INFO);
} }
public void clusterGetKeysInSlot(final int slot, final int count) { public void clusterGetKeysInSlot(final int slot, final int count) {
final int[] args = new int[]{ slot, count }; final int[] args = new int[] { slot, count };
cluster(Protocol.CLUSTER_GETKEYSINSLOT, args); cluster(Protocol.CLUSTER_GETKEYSINSLOT, args);
} }
public void clusterSetSlotNode(final int slot, final String nodeId) { public void clusterSetSlotNode(final int slot, final String nodeId) {
cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_NODE, nodeId); cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot),
Protocol.CLUSTER_SETSLOT_NODE, nodeId);
} }
public void clusterSetSlotMigrating(final int slot, final String nodeId) { public void clusterSetSlotMigrating(final int slot, final String nodeId) {
cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_MIGRATING, nodeId); cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot),
Protocol.CLUSTER_SETSLOT_MIGRATING, nodeId);
} }
public void clusterSetSlotImporting(final int slot, final String nodeId) { public void clusterSetSlotImporting(final int slot, final String nodeId) {
cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_IMPORTING, nodeId); cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot),
Protocol.CLUSTER_SETSLOT_IMPORTING, nodeId);
} }
} }

2
src/main/java/redis/clients/jedis/Commands.java
View File

@@ -144,7 +144,7 @@ public interface Commands {
public void zadd(final String key, final double score, final String member); public void zadd(final String key, final double score, final String member);
public void zadd(final String key, final Map<Double, String> scoreMembers); public void zadd(final String key, final Map<String, Double> scoreMembers);
public void zrange(final String key, final long start, final long end); public void zrange(final String key, final long start, final long end);

256
src/main/java/redis/clients/jedis/Connection.java
View File

@@ -25,218 +25,230 @@ public class Connection {
private int timeout = Protocol.DEFAULT_TIMEOUT; private int timeout = Protocol.DEFAULT_TIMEOUT;
public Socket getSocket() { public Socket getSocket() {
return socket; return socket;
} }
public int getTimeout() { public int getTimeout() {
return timeout; return timeout;
} }
public void setTimeout(final int timeout) { public void setTimeout(final int timeout) {
this.timeout = timeout; this.timeout = timeout;
} }
public void setTimeoutInfinite() { public void setTimeoutInfinite() {
try { try {
if(!isConnected()) { if (!isConnected()) {
connect(); connect();
} }
socket.setKeepAlive(true); socket.setKeepAlive(true);
socket.setSoTimeout(0); socket.setSoTimeout(0);
} catch (SocketException ex) { } catch (SocketException ex) {
throw new JedisException(ex); throw new JedisException(ex);
} }
} }
public void rollbackTimeout() { public void rollbackTimeout() {
try { try {
socket.setSoTimeout(timeout); socket.setSoTimeout(timeout);
socket.setKeepAlive(false); socket.setKeepAlive(false);
} catch (SocketException ex) { } catch (SocketException ex) {
throw new JedisException(ex); throw new JedisException(ex);
} }
} }
public Connection(final String host) { public Connection(final String host) {
super(); super();
this.host = host; this.host = host;
} }
protected void flush() { protected void flush() {
try { try {
outputStream.flush(); outputStream.flush();
} catch (IOException e) { } catch (IOException e) {
throw new JedisConnectionException(e); throw new JedisConnectionException(e);
} }
} }
protected Connection sendCommand(final Command cmd, final String... args) { protected Connection sendCommand(final Command cmd, final String... args) {
final byte[][] bargs = new byte[args.length][]; final byte[][] bargs = new byte[args.length][];
for (int i = 0; i < args.length; i++) { for (int i = 0; i < args.length; i++) {
bargs[i] = SafeEncoder.encode(args[i]); bargs[i] = SafeEncoder.encode(args[i]);
} }
return sendCommand(cmd, bargs); return sendCommand(cmd, bargs);
} }
protected Connection sendCommand(final Command cmd, final byte[]... args) { protected Connection sendCommand(final Command cmd, final byte[]... args) {
connect(); connect();
Protocol.sendCommand(outputStream, cmd, args); Protocol.sendCommand(outputStream, cmd, args);
pipelinedCommands++; pipelinedCommands++;
return this; return this;
} }
protected Connection sendCommand(final Command cmd) { protected Connection sendCommand(final Command cmd) {
connect(); connect();
Protocol.sendCommand(outputStream, cmd, new byte[0][]); Protocol.sendCommand(outputStream, cmd, new byte[0][]);
pipelinedCommands++; pipelinedCommands++;
return this; return this;
} }
public Connection(final String host, final int port) { public Connection(final String host, final int port) {
super(); super();
this.host = host; this.host = host;
this.port = port; this.port = port;
} }
public String getHost() { public String getHost() {
return host; return host;
} }
public void setHost(final String host) { public void setHost(final String host) {
this.host = host; this.host = host;
} }
public int getPort() { public int getPort() {
return port; return port;
} }
public void setPort(final int port) { public void setPort(final int port) {
this.port = port; this.port = port;
} }
public Connection() { public Connection() {
} }
public void connect() { public void connect() {
if (!isConnected()) { if (!isConnected()) {
try { try {
socket = new Socket(); socket = new Socket();
//->@wjw_add // ->@wjw_add
socket.setReuseAddress(true); socket.setReuseAddress(true);
socket.setKeepAlive(true); //Will monitor the TCP connection is valid socket.setKeepAlive(true); // Will monitor the TCP connection is
socket.setTcpNoDelay(true); //Socket buffer Whetherclosed, to ensure timely delivery of data // valid
socket.setSoLinger(true,0); //Control calls close () method, the underlying socket is closed immediately socket.setTcpNoDelay(true); // Socket buffer Whetherclosed, to
//<-@wjw_add // ensure timely delivery of data
socket.setSoLinger(true, 0); // Control calls close () method,
// the underlying socket is closed
// immediately
// <-@wjw_add
socket.connect(new InetSocketAddress(host, port), timeout); socket.connect(new InetSocketAddress(host, port), timeout);
socket.setSoTimeout(timeout); socket.setSoTimeout(timeout);
outputStream = new RedisOutputStream(socket.getOutputStream()); outputStream = new RedisOutputStream(socket.getOutputStream());
inputStream = new RedisInputStream(socket.getInputStream()); inputStream = new RedisInputStream(socket.getInputStream());
} catch (IOException ex) { } catch (IOException ex) {
throw new JedisConnectionException(ex); throw new JedisConnectionException(ex);
} }
} }
} }
public void disconnect() { public void disconnect() {
if (isConnected()) { if (isConnected()) {
try { try {
inputStream.close(); inputStream.close();
outputStream.close(); outputStream.close();
if (!socket.isClosed()) { if (!socket.isClosed()) {
socket.close(); socket.close();
} }
} catch (IOException ex) { } catch (IOException ex) {
throw new JedisConnectionException(ex); throw new JedisConnectionException(ex);
} }
} }
} }
public boolean isConnected() { public boolean isConnected() {
return socket != null && socket.isBound() && !socket.isClosed() return socket != null && socket.isBound() && !socket.isClosed()
&& socket.isConnected() && !socket.isInputShutdown() && socket.isConnected() && !socket.isInputShutdown()
&& !socket.isOutputShutdown(); && !socket.isOutputShutdown();
} }
protected String getStatusCodeReply() { protected String getStatusCodeReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
final byte[] resp = (byte[]) Protocol.read(inputStream); final byte[] resp = (byte[]) Protocol.read(inputStream);
if (null == resp) { if (null == resp) {
return null; return null;
} else { } else {
return SafeEncoder.encode(resp); return SafeEncoder.encode(resp);
} }
} }
public String getBulkReply() { public String getBulkReply() {
final byte[] result = getBinaryBulkReply(); final byte[] result = getBinaryBulkReply();
if (null != result) { if (null != result) {
return SafeEncoder.encode(result); return SafeEncoder.encode(result);
} else { } else {
return null; return null;
} }
} }
public byte[] getBinaryBulkReply() { public byte[] getBinaryBulkReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return (byte[]) Protocol.read(inputStream); return (byte[]) Protocol.read(inputStream);
} }
public Long getIntegerReply() { public Long getIntegerReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return (Long) Protocol.read(inputStream); return (Long) Protocol.read(inputStream);
} }
public List<String> getMultiBulkReply() { public List<String> getMultiBulkReply() {
return BuilderFactory.STRING_LIST.build(getBinaryMultiBulkReply()); return BuilderFactory.STRING_LIST.build(getBinaryMultiBulkReply());
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<byte[]> getBinaryMultiBulkReply() { public List<byte[]> getBinaryMultiBulkReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return (List<byte[]>) Protocol.read(inputStream); return (List<byte[]>) Protocol.read(inputStream);
}
public void resetPipelinedCount() {
pipelinedCommands = 0;
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<Object> getRawObjectMultiBulkReply() {
return (List<Object>) Protocol.read(inputStream);
}
public List<Object> getObjectMultiBulkReply() { public List<Object> getObjectMultiBulkReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return (List<Object>) Protocol.read(inputStream); return getRawObjectMultiBulkReply();
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<Long> getIntegerMultiBulkReply() { public List<Long> getIntegerMultiBulkReply() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return (List<Long>) Protocol.read(inputStream); return (List<Long>) Protocol.read(inputStream);
} }
public List<Object> getAll() { public List<Object> getAll() {
return getAll(0); return getAll(0);
} }
public List<Object> getAll(int except) { public List<Object> getAll(int except) {
List<Object> all = new ArrayList<Object>(); List<Object> all = new ArrayList<Object>();
flush(); flush();
while (pipelinedCommands > except) { while (pipelinedCommands > except) {
try{ try {
all.add(Protocol.read(inputStream)); all.add(Protocol.read(inputStream));
}catch(JedisDataException e){ } catch (JedisDataException e) {
all.add(e); all.add(e);
} }
pipelinedCommands--; pipelinedCommands--;
} }
return all; return all;
} }
public Object getOne() { public Object getOne() {
flush(); flush();
pipelinedCommands--; pipelinedCommands--;
return Protocol.read(inputStream); return Protocol.read(inputStream);
} }
} }

77
src/main/java/redis/clients/jedis/HostAndPort.java
View File

@@ -1,50 +1,49 @@
package redis.clients.jedis; package redis.clients.jedis;
public class HostAndPort { public class HostAndPort {
public static final String LOCALHOST_STR = "localhost"; public static final String LOCALHOST_STR = "localhost";
private String host; private String host;
private int port; private int port;
public HostAndPort(String host, int port) { public HostAndPort(String host, int port) {
this.host = host; this.host = host;
this.port = port; this.port = port;
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof HostAndPort) {
HostAndPort hp = (HostAndPort) obj;
String thisHost = convertHost(host);
String hpHost = convertHost(hp.host);
return port == hp.port && thisHost.equals(hpHost);
} }
public String getHost() { return false;
return host; }
}
public int getPort() { @Override
return port; public String toString() {
} return host + ":" + port;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof HostAndPort) {
HostAndPort hp = (HostAndPort) obj;
String thisHost = convertHost(host);
String hpHost = convertHost(hp.host);
return port == hp.port &&
thisHost.equals(hpHost);
}
return false;
}
@Override
public String toString() {
return host + ":" + port;
}
private String convertHost(String host) { private String convertHost(String host) {
if (host.equals("127.0.0.1")) if (host.equals("127.0.0.1"))
return LOCALHOST_STR; return LOCALHOST_STR;
else if (host.equals("::1")) else if (host.equals("::1"))
return LOCALHOST_STR; return LOCALHOST_STR;
return host; return host;
} }
} }

422
src/main/java/redis/clients/jedis/Jedis.java
View File

@@ -15,7 +15,9 @@ import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
import redis.clients.util.Slowlog; import redis.clients.util.Slowlog;
public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands, BasicCommands, ClusterCommands, SentinelCommands { public class Jedis extends BinaryJedis implements JedisCommands,
MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands,
BasicCommands, ClusterCommands {
public Jedis(final String host) { public Jedis(final String host) {
super(host); super(host);
} }
@@ -55,24 +57,29 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
/** /**
* Set the string value as value of the key. The string can't be longer than * Set the string value as value of the key. The string can't be longer than
* 1073741824 bytes (1 GB). * 1073741824 bytes (1 GB).
*
* @param key * @param key
* @param value * @param value
* @param nxxx NX|XX, NX -- Only set the key if it does not already exist. * @param nxxx
* XX -- Only set the key if it already exist. * NX|XX, NX -- Only set the key if it does not already exist. XX
* @param expx EX|PX, expire time units: EX = seconds; PX = milliseconds * -- Only set the key if it already exist.
* @param time expire time in the units of {@param #expx} * @param expx
* EX|PX, expire time units: EX = seconds; PX = milliseconds
* @param time
* expire time in the units of {@param #expx}
* @return Status code reply * @return Status code reply
*/ */
public String set(final String key, final String value, final String nxxx, final String expx, final long time) { public String set(final String key, final String value, final String nxxx,
checkIsInMulti(); final String expx, final long time) {
client.set(key, value, nxxx, expx, time); checkIsInMulti();
return client.getStatusCodeReply(); client.set(key, value, nxxx, expx, time);
return client.getStatusCodeReply();
} }
/** /**
* Get the value of the specified key. If the key does not exist the special * Get the value of the specified key. If the key does not exist null is
* value 'nil' is returned. If the value stored at key is not a string an * returned. If the value stored at key is not a string an error is returned
* error is returned because GET can only handle string values. * because GET can only handle string values.
* <p> * <p>
* Time complexity: O(1) * Time complexity: O(1)
* *
@@ -118,8 +125,8 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public Long del(String key) { public Long del(String key) {
client.del(key); client.del(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
/** /**
@@ -1380,7 +1387,7 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
client.srandmember(key); client.srandmember(key);
return client.getBulkReply(); return client.getBulkReply();
} }
public List<String> srandmember(final String key, final int count) { public List<String> srandmember(final String key, final int count) {
checkIsInMulti(); checkIsInMulti();
client.srandmember(key, count); client.srandmember(key, count);
@@ -1414,7 +1421,7 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long zadd(final String key, final Map<Double, String> scoreMembers) { public Long zadd(final String key, final Map<String, Double> scoreMembers) {
checkIsInMulti(); checkIsInMulti();
client.zadd(key, scoreMembers); client.zadd(key, scoreMembers);
return client.getIntegerReply(); return client.getIntegerReply();
@@ -1788,39 +1795,39 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public List<String> blpop(String... args) { public List<String> blpop(String... args) {
client.blpop(args); client.blpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply(); final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<String> brpop(String... args) { public List<String> brpop(String... args) {
client.brpop(args); client.brpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply(); final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<String> blpop(String arg) { public List<String> blpop(String arg) {
String[] args = new String[1]; String[] args = new String[1];
args[0] = arg; args[0] = arg;
client.blpop(args); client.blpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply(); final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
public List<String> brpop(String arg) { public List<String> brpop(String arg) {
String[] args = new String[1]; String[] args = new String[1];
args[0] = arg; args[0] = arg;
client.brpop(args); client.brpop(args);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply(); final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout(); client.rollbackTimeout();
return multiBulkReply; return multiBulkReply;
} }
/** /**
@@ -1953,8 +1960,6 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
return multiBulkReply; return multiBulkReply;
} }
public Long zcount(final String key, final double min, final double max) { public Long zcount(final String key, final double min, final double max) {
checkIsInMulti(); checkIsInMulti();
client.zcount(key, min, max); client.zcount(key, min, max);
@@ -2019,8 +2024,10 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
* @see #zcount(String, double, double) * @see #zcount(String, double, double)
* *
* @param key * @param key
* @param min a double or Double.MIN_VALUE for "-inf" * @param min
* @param max a double or Double.MAX_VALUE for "+inf" * a double or Double.MIN_VALUE for "-inf"
* @param max
* a double or Double.MAX_VALUE for "+inf"
* @return Multi bulk reply specifically a list of elements in the specified * @return Multi bulk reply specifically a list of elements in the specified
* score range. * score range.
*/ */
@@ -2627,8 +2634,8 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public Boolean setbit(String key, long offset, String value) { public Boolean setbit(String key, long offset, String value) {
client.setbit(key, offset, value); client.setbit(key, offset, value);
return client.getIntegerReply() == 1; return client.getIntegerReply() == 1;
} }
/** /**
@@ -2741,26 +2748,26 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public void subscribe(final JedisPubSub jedisPubSub, public void subscribe(final JedisPubSub jedisPubSub,
final String... channels) { final String... channels) {
client.setTimeoutInfinite(); client.setTimeoutInfinite();
jedisPubSub.proceed(client, channels); jedisPubSub.proceed(client, channels);
client.rollbackTimeout(); client.rollbackTimeout();
} }
public Long publish(final String channel, final String message) { public Long publish(final String channel, final String message) {
checkIsInMulti(); checkIsInMulti();
connect(); connect();
client.publish(channel, message); client.publish(channel, message);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public void psubscribe(final JedisPubSub jedisPubSub, public void psubscribe(final JedisPubSub jedisPubSub,
final String... patterns) { final String... patterns) {
checkIsInMulti(); checkIsInMulti();
connect(); connect();
client.setTimeoutInfinite(); client.setTimeoutInfinite();
jedisPubSub.proceedWithPatterns(client, patterns); jedisPubSub.proceedWithPatterns(client, patterns);
client.rollbackTimeout(); client.rollbackTimeout();
} }
protected static String[] getParams(List<String> keys, List<String> args) { protected static String[] getParams(List<String> keys, List<String> args) {
@@ -2792,7 +2799,7 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
private Object getEvalResult() { private Object getEvalResult() {
Object result = client.getOne(); Object result = client.getOne();
if (result instanceof byte[]) if (result instanceof byte[])
return SafeEncoder.encode((byte[]) result); return SafeEncoder.encode((byte[]) result);
@@ -2869,18 +2876,18 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public Long bitcount(final String key) { public Long bitcount(final String key) {
client.bitcount(key); client.bitcount(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long bitcount(final String key, long start, long end) { public Long bitcount(final String key, long start, long end) {
client.bitcount(key, start, end); client.bitcount(key, start, end);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long bitop(BitOP op, final String destKey, String... srcKeys) { public Long bitop(BitOP op, final String destKey, String... srcKeys) {
client.bitop(op, destKey, srcKeys); client.bitop(op, destKey, srcKeys);
return client.getIntegerReply(); return client.getIntegerReply();
} }
/** /**
@@ -2916,7 +2923,7 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
* @return * @return
*/ */
@SuppressWarnings("rawtypes") @SuppressWarnings("rawtypes")
public List<Map<String, String>> sentinelMasters() { public List<Map<String, String>> sentinelMasters() {
client.sentinel(Protocol.SENTINEL_MASTERS); client.sentinel(Protocol.SENTINEL_MASTERS);
final List<Object> reply = client.getObjectMultiBulkReply(); final List<Object> reply = client.getObjectMultiBulkReply();
@@ -2994,7 +3001,7 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
* @return * @return
*/ */
@SuppressWarnings("rawtypes") @SuppressWarnings("rawtypes")
public List<Map<String, String>> sentinelSlaves(String masterName) { public List<Map<String, String>> sentinelSlaves(String masterName) {
client.sentinel(Protocol.SENTINEL_SLAVES, masterName); client.sentinel(Protocol.SENTINEL_SLAVES, masterName);
final List<Object> reply = client.getObjectMultiBulkReply(); final List<Object> reply = client.getObjectMultiBulkReply();
@@ -3038,212 +3045,243 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
} }
public byte[] dump(final String key) { public byte[] dump(final String key) {
checkIsInMulti(); checkIsInMulti();
client.dump(key); client.dump(key);
return client.getBinaryBulkReply(); return client.getBinaryBulkReply();
} }
public String restore(final String key, final int ttl, final byte[] serializedValue) { public String restore(final String key, final int ttl,
checkIsInMulti(); final byte[] serializedValue) {
client.restore(key, ttl, serializedValue); checkIsInMulti();
return client.getStatusCodeReply(); client.restore(key, ttl, serializedValue);
return client.getStatusCodeReply();
} }
public Long pexpire(final String key, final int milliseconds) { public Long pexpire(final String key, final int milliseconds) {
checkIsInMulti(); checkIsInMulti();
client.pexpire(key, milliseconds); client.pexpire(key, milliseconds);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long pexpireAt(final String key, final long millisecondsTimestamp) { public Long pexpireAt(final String key, final long millisecondsTimestamp) {
checkIsInMulti(); checkIsInMulti();
client.pexpireAt(key, millisecondsTimestamp); client.pexpireAt(key, millisecondsTimestamp);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Long pttl(final String key) { public Long pttl(final String key) {
checkIsInMulti(); checkIsInMulti();
client.pttl(key); client.pttl(key);
return client.getIntegerReply(); return client.getIntegerReply();
} }
public Double incrByFloat(final String key, final double increment) { public Double incrByFloat(final String key, final double increment) {
checkIsInMulti(); checkIsInMulti();
client.incrByFloat(key, increment); client.incrByFloat(key, increment);
String relpy = client.getBulkReply(); String relpy = client.getBulkReply();
return (relpy != null ? new Double(relpy) : null); return (relpy != null ? new Double(relpy) : null);
} }
public String psetex(final String key, final int milliseconds, final String value) { public String psetex(final String key, final int milliseconds,
checkIsInMulti(); final String value) {
client.psetex(key, milliseconds, value); checkIsInMulti();
return client.getStatusCodeReply(); client.psetex(key, milliseconds, value);
return client.getStatusCodeReply();
} }
public String set(final String key, final String value, final String nxxx) { public String set(final String key, final String value, final String nxxx) {
checkIsInMulti(); checkIsInMulti();
client.set(key, value, nxxx); client.set(key, value, nxxx);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String set(final String key, final String value, final String nxxx, final String expx, final int time) { public String set(final String key, final String value, final String nxxx,
checkIsInMulti(); final String expx, final int time) {
client.set(key, value, nxxx, expx, time); checkIsInMulti();
return client.getStatusCodeReply(); client.set(key, value, nxxx, expx, time);
return client.getStatusCodeReply();
} }
public String clientKill(final String client) { public String clientKill(final String client) {
checkIsInMulti(); checkIsInMulti();
this.client.clientKill(client); this.client.clientKill(client);
return this.client.getStatusCodeReply(); return this.client.getStatusCodeReply();
} }
public String clientSetname(final String name) { public String clientSetname(final String name) {
checkIsInMulti(); checkIsInMulti();
client.clientSetname(name); client.clientSetname(name);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String migrate(final String host, final int port, final String key, final int destinationDb, final int timeout) { public String migrate(final String host, final int port, final String key,
checkIsInMulti(); final int destinationDb, final int timeout) {
client.migrate(host, port, key, destinationDb, timeout); checkIsInMulti();
return client.getStatusCodeReply(); client.migrate(host, port, key, destinationDb, timeout);
return client.getStatusCodeReply();
} }
public Double hincrByFloat(final String key, final String field, double increment) { public Double hincrByFloat(final String key, final String field,
checkIsInMulti(); double increment) {
client.hincrByFloat(key, field, increment); checkIsInMulti();
String relpy = client.getBulkReply(); client.hincrByFloat(key, field, increment);
return (relpy != null ? new Double(relpy) : null); String relpy = client.getBulkReply();
return (relpy != null ? new Double(relpy) : null);
} }
public ScanResult<String> scan(int cursor) { public ScanResult<String> scan(int cursor) {
return scan(cursor, new ScanParams()); return scan(cursor, new ScanParams());
} }
public ScanResult<String> scan(int cursor, final ScanParams params) { public ScanResult<String> scan(int cursor, final ScanParams params) {
checkIsInMulti(); checkIsInMulti();
client.scan(cursor, params); client.scan(cursor, params);
List<Object> result = client.getObjectMultiBulkReply(); List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0))); int newcursor = Integer.parseInt(new String((byte[]) result.get(0)));
List<String> results = new ArrayList<String>(); List<String> results = new ArrayList<String>();
List<byte[]> rawResults = (List<byte[]>)result.get(1); List<byte[]> rawResults = (List<byte[]>) result.get(1);
for (byte[] bs : rawResults) { for (byte[] bs : rawResults) {
results.add(SafeEncoder.encode(bs)); results.add(SafeEncoder.encode(bs));
} }
return new ScanResult<String>(newcursor, results); return new ScanResult<String>(newcursor, results);
} }
public ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor) { public ScanResult<Map.Entry<String, String>> hscan(final String key,
int cursor) {
return hscan(key, cursor, new ScanParams()); return hscan(key, cursor, new ScanParams());
} }
public ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor, final ScanParams params) { public ScanResult<Map.Entry<String, String>> hscan(final String key,
int cursor, final ScanParams params) {
checkIsInMulti(); checkIsInMulti();
client.hscan(key, cursor, params); client.hscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply(); List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0))); int newcursor = Integer.parseInt(new String((byte[]) result.get(0)));
List<Map.Entry<String, String>> results = new ArrayList<Map.Entry<String, String>>(); List<Map.Entry<String, String>> results = new ArrayList<Map.Entry<String, String>>();
List<byte[]> rawResults = (List<byte[]>)result.get(1); List<byte[]> rawResults = (List<byte[]>) result.get(1);
Iterator<byte[]> iterator = rawResults.iterator(); Iterator<byte[]> iterator = rawResults.iterator();
while(iterator.hasNext()) { while (iterator.hasNext()) {
results.add(new AbstractMap.SimpleEntry<String, String>(SafeEncoder.encode(iterator.next()), SafeEncoder.encode(iterator.next()))); results.add(new AbstractMap.SimpleEntry<String, String>(SafeEncoder
.encode(iterator.next()), SafeEncoder.encode(iterator
.next())));
} }
return new ScanResult<Map.Entry<String, String>>(newcursor, results); return new ScanResult<Map.Entry<String, String>>(newcursor, results);
} }
public ScanResult<String> sscan(final String key, int cursor) { public ScanResult<String> sscan(final String key, int cursor) {
return sscan(key, cursor, new ScanParams()); return sscan(key, cursor, new ScanParams());
} }
public ScanResult<String> sscan(final String key, int cursor, final ScanParams params) { public ScanResult<String> sscan(final String key, int cursor,
final ScanParams params) {
checkIsInMulti(); checkIsInMulti();
client.sscan(key, cursor, params); client.sscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply(); List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0))); int newcursor = Integer.parseInt(new String((byte[]) result.get(0)));
List<String> results = new ArrayList<String>(); List<String> results = new ArrayList<String>();
List<byte[]> rawResults = (List<byte[]>)result.get(1); List<byte[]> rawResults = (List<byte[]>) result.get(1);
for (byte[] bs : rawResults) { for (byte[] bs : rawResults) {
results.add(SafeEncoder.encode(bs)); results.add(SafeEncoder.encode(bs));
} }
return new ScanResult<String>(newcursor, results); return new ScanResult<String>(newcursor, results);
} }
public ScanResult<Tuple> zscan(final String key, int cursor) { public ScanResult<Tuple> zscan(final String key, int cursor) {
return zscan(key, cursor, new ScanParams()); return zscan(key, cursor, new ScanParams());
} }
public ScanResult<Tuple> zscan(final String key, int cursor, final ScanParams params) { public ScanResult<Tuple> zscan(final String key, int cursor,
final ScanParams params) {
checkIsInMulti(); checkIsInMulti();
client.zscan(key, cursor, params); client.zscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply(); List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0))); int newcursor = Integer.parseInt(new String((byte[]) result.get(0)));
List<Tuple> results = new ArrayList<Tuple>(); List<Tuple> results = new ArrayList<Tuple>();
List<byte[]> rawResults = (List<byte[]>)result.get(1); List<byte[]> rawResults = (List<byte[]>) result.get(1);
Iterator<byte[]> iterator = rawResults.iterator(); Iterator<byte[]> iterator = rawResults.iterator();
while(iterator.hasNext()) { while (iterator.hasNext()) {
results.add(new Tuple(SafeEncoder.encode(iterator.next()), Double.valueOf(SafeEncoder.encode(iterator.next())))); results.add(new Tuple(SafeEncoder.encode(iterator.next()), Double
.valueOf(SafeEncoder.encode(iterator.next()))));
} }
return new ScanResult<Tuple>(newcursor, results); return new ScanResult<Tuple>(newcursor, results);
} }
public String clusterNodes() { public String clusterNodes() {
checkIsInMulti(); checkIsInMulti();
client.clusterNodes(); client.clusterNodes();
return client.getBulkReply(); return client.getBulkReply();
} }
public String clusterMeet(final String ip, final int port) { public String clusterMeet(final String ip, final int port) {
checkIsInMulti(); checkIsInMulti();
client.clusterMeet(ip, port); client.clusterMeet(ip, port);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String clusterAddSlots(final int ...slots) { public String clusterAddSlots(final int... slots) {
checkIsInMulti(); checkIsInMulti();
client.clusterAddSlots(slots); client.clusterAddSlots(slots);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String clusterDelSlots(final int ...slots) { public String clusterDelSlots(final int... slots) {
checkIsInMulti(); checkIsInMulti();
client.clusterDelSlots(slots); client.clusterDelSlots(slots);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String clusterInfo() { public String clusterInfo() {
checkIsInMulti(); checkIsInMulti();
client.clusterInfo(); client.clusterInfo();
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public List<String> clusterGetKeysInSlot(final int slot, final int count) { public List<String> clusterGetKeysInSlot(final int slot, final int count) {
checkIsInMulti(); checkIsInMulti();
client.clusterGetKeysInSlot(slot, count); client.clusterGetKeysInSlot(slot, count);
return client.getMultiBulkReply(); return client.getMultiBulkReply();
} }
public String clusterSetSlotNode(final int slot, final String nodeId) { public String clusterSetSlotNode(final int slot, final String nodeId) {
checkIsInMulti(); checkIsInMulti();
client.clusterSetSlotNode(slot, nodeId); client.clusterSetSlotNode(slot, nodeId);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String clusterSetSlotMigrating(final int slot, final String nodeId) { public String clusterSetSlotMigrating(final int slot, final String nodeId) {
checkIsInMulti(); checkIsInMulti();
client.clusterSetSlotMigrating(slot, nodeId); client.clusterSetSlotMigrating(slot, nodeId);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String clusterSetSlotImporting(final int slot, final String nodeId) { public String clusterSetSlotImporting(final int slot, final String nodeId) {
checkIsInMulti(); checkIsInMulti();
client.clusterSetSlotImporting(slot, nodeId); client.clusterSetSlotImporting(slot, nodeId);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public String asking() { public String asking() {
checkIsInMulti(); checkIsInMulti();
client.asking(); client.asking();
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public List<String> pubsubChannels(String pattern) {
checkIsInMulti();
client.pubsubChannels(pattern);
return client.getMultiBulkReply();
}
public Long pubsubNumPat() {
checkIsInMulti();
client.pubsubNumPat();
return client.getIntegerReply();
}
public Map<String, String> pubsubNumSub(String... channels) {
checkIsInMulti();
client.pubsubNumSub(channels);
return BuilderFactory.STRING_MAP
.build(client.getBinaryMultiBulkReply());
}
} }

2
src/main/java/redis/clients/jedis/JedisCluster.java
View File

@@ -635,7 +635,7 @@ public class JedisCluster implements JedisCommands, BasicCommands {
} }
@Override @Override
public Long zadd(final String key, final Map<Double, String> scoreMembers) { public Long zadd(final String key, final Map<String, Double> scoreMembers) {
return new JedisClusterCommand<Long>(connectionHandler, timeout, return new JedisClusterCommand<Long>(connectionHandler, timeout,
maxRedirections) { maxRedirections) {
@Override @Override

87
src/main/java/redis/clients/jedis/JedisClusterCommand.java
View File

@@ -7,47 +7,54 @@ import redis.clients.jedis.exceptions.JedisRedirectionException;
import redis.clients.util.JedisClusterCRC16; import redis.clients.util.JedisClusterCRC16;
public abstract class JedisClusterCommand<T> { public abstract class JedisClusterCommand<T> {
private boolean asking = false;
private JedisClusterConnectionHandler connectionHandler;
private int commandTimeout;
private int redirections;
// private boolean asking = false;
public JedisClusterCommand(JedisClusterConnectionHandler connectionHandler, int timeout, int maxRedirections) {
this.connectionHandler = connectionHandler;
this.commandTimeout = timeout;
this.redirections = maxRedirections;
}
public abstract T execute(); private boolean asking = false;
public T run(String key) {
try {
if (key == null) {
throw new JedisClusterException("No way to dispatch this command to Redis Cluster.");
} else if (redirections == 0) {
throw new JedisClusterMaxRedirectionsException("Too many Cluster redirections?");
}
connectionHandler.getConnectionFromSlot(JedisClusterCRC16.getSlot(key));
if (asking) {
//TODO: Pipeline asking with the original command to make it faster....
connectionHandler.getConnection().asking();
}
return execute();
} catch (JedisRedirectionException jre) {
return handleRedirection(jre, key);
}
}
private T handleRedirection(JedisRedirectionException jre, String key) { private JedisClusterConnectionHandler connectionHandler;
if (jre instanceof JedisAskDataException) { private int commandTimeout;
asking = true; private int redirections;
}
redirections--; // private boolean asking = false;
this.connectionHandler.assignSlotToNode(jre.getSlot(), jre.getTargetNode());
return run(key); public JedisClusterCommand(JedisClusterConnectionHandler connectionHandler,
int timeout, int maxRedirections) {
this.connectionHandler = connectionHandler;
this.commandTimeout = timeout;
this.redirections = maxRedirections;
}
public abstract T execute();
public T run(String key) {
try {
if (key == null) {
throw new JedisClusterException(
"No way to dispatch this command to Redis Cluster.");
} else if (redirections == 0) {
throw new JedisClusterMaxRedirectionsException(
"Too many Cluster redirections?");
}
connectionHandler.getConnectionFromSlot(JedisClusterCRC16
.getSlot(key));
if (asking) {
// TODO: Pipeline asking with the original command to make it
// faster....
connectionHandler.getConnection().asking();
}
return execute();
} catch (JedisRedirectionException jre) {
return handleRedirection(jre, key);
} }
}
private T handleRedirection(JedisRedirectionException jre, String key) {
if (jre instanceof JedisAskDataException) {
asking = true;
}
redirections--;
this.connectionHandler.assignSlotToNode(jre.getSlot(),
jre.getTargetNode());
return run(key);
}
} }

128
src/main/java/redis/clients/jedis/JedisClusterConnectionHandler.java
View File

@@ -5,78 +5,80 @@ import java.util.Map;
import java.util.Random; import java.util.Random;
import java.util.Set; import java.util.Set;
public abstract class JedisClusterConnectionHandler { public abstract class JedisClusterConnectionHandler {
protected Map<String, JedisPool> nodes = new HashMap<String, JedisPool>();
protected Map<Integer, JedisPool> slots = new HashMap<Integer, JedisPool>();
abstract Jedis getConnection();
abstract Jedis getConnectionFromSlot(int slot);
public JedisClusterConnectionHandler(Set<HostAndPort> nodes) {
initializeSlotsCache(nodes);
}
public Map<String, JedisPool> getNodes() {
return nodes;
}
private void initializeSlotsCache(Set<HostAndPort> nodes) {
for (HostAndPort hostAndPort : nodes) {
JedisPool jp = new JedisPool(hostAndPort.getHost(), hostAndPort.getPort());
this.nodes.put(hostAndPort.getHost() + hostAndPort.getPort(), jp);
discoverClusterNodesAndSlots(jp);
}
protected Map<String, JedisPool> nodes = new HashMap<String, JedisPool>();
protected Map<Integer, JedisPool> slots = new HashMap<Integer, JedisPool>();
abstract Jedis getConnection();
abstract Jedis getConnectionFromSlot(int slot);
public JedisClusterConnectionHandler(Set<HostAndPort> nodes) {
initializeSlotsCache(nodes);
}
public Map<String, JedisPool> getNodes() {
return nodes;
}
private void initializeSlotsCache(Set<HostAndPort> nodes) {
for (HostAndPort hostAndPort : nodes) {
JedisPool jp = new JedisPool(hostAndPort.getHost(),
hostAndPort.getPort());
this.nodes.put(hostAndPort.getHost() + hostAndPort.getPort(), jp);
discoverClusterNodesAndSlots(jp);
} }
private void discoverClusterNodesAndSlots(JedisPool jp) { }
String localNodes = jp.getResource().clusterNodes();
for (String nodeInfo : localNodes.split("\n")) {
HostAndPort node = getHostAndPortFromNodeLine(nodeInfo);
JedisPool nodePool = new JedisPool(node.getHost(), node.getPort());
this.nodes.put(node.getHost() + node.getPort(), nodePool);
populateNodeSlots(nodeInfo, nodePool);
}
}
private void populateNodeSlots(String nodeInfo, JedisPool nodePool) { private void discoverClusterNodesAndSlots(JedisPool jp) {
String[] nodeInfoArray = nodeInfo.split(" "); String localNodes = jp.getResource().clusterNodes();
if (nodeInfoArray.length > 7) { for (String nodeInfo : localNodes.split("\n")) {
for (int i = 8; i < nodeInfoArray.length; i++) { HostAndPort node = getHostAndPortFromNodeLine(nodeInfo);
processSlot(nodeInfoArray[i], nodePool); JedisPool nodePool = new JedisPool(node.getHost(), node.getPort());
} this.nodes.put(node.getHost() + node.getPort(), nodePool);
} populateNodeSlots(nodeInfo, nodePool);
} }
}
private void processSlot(String slot, JedisPool nodePool) { private void populateNodeSlots(String nodeInfo, JedisPool nodePool) {
if (slot.contains("-")) { String[] nodeInfoArray = nodeInfo.split(" ");
String[] slotRange = slot.split("-"); if (nodeInfoArray.length > 7) {
for (int i = Integer.valueOf(slotRange[0]); i <= Integer.valueOf(slotRange[1]); i++) { for (int i = 8; i < nodeInfoArray.length; i++) {
slots.put(i, nodePool); processSlot(nodeInfoArray[i], nodePool);
} }
} else {
slots.put(Integer.valueOf(slot), nodePool);
}
} }
}
private HostAndPort getHostAndPortFromNodeLine(String nodeInfo) { private void processSlot(String slot, JedisPool nodePool) {
String stringHostAndPort = nodeInfo.split(" ",3)[1]; if (slot.contains("-")) {
String[] arrayHostAndPort = stringHostAndPort.split(":"); String[] slotRange = slot.split("-");
return new HostAndPort(arrayHostAndPort[0], Integer.valueOf(arrayHostAndPort[1])); for (int i = Integer.valueOf(slotRange[0]); i <= Integer
.valueOf(slotRange[1]); i++) {
slots.put(i, nodePool);
}
} else {
slots.put(Integer.valueOf(slot), nodePool);
} }
}
private HostAndPort getHostAndPortFromNodeLine(String nodeInfo) {
String stringHostAndPort = nodeInfo.split(" ", 3)[1];
String[] arrayHostAndPort = stringHostAndPort.split(":");
return new HostAndPort(arrayHostAndPort[0],
Integer.valueOf(arrayHostAndPort[1]));
}
public void assignSlotToNode(int slot, HostAndPort targetNode) {
JedisPool targetPool = nodes.get(targetNode.getHost()
+ targetNode.getPort());
slots.put(slot, targetPool);
}
protected JedisPool getRandomConnection() {
Object[] nodeArray = nodes.values().toArray();
return (JedisPool) (nodeArray[new Random().nextInt(nodeArray.length)]);
}
public void assignSlotToNode(int slot, HostAndPort targetNode) {
JedisPool targetPool = nodes.get(targetNode.getHost() + targetNode.getPort());
slots.put(slot, targetPool);
}
protected JedisPool getRandomConnection() {
Object[] nodeArray = nodes.values().toArray();
return (JedisPool) (nodeArray[new Random().nextInt(nodeArray.length)]);
}
} }

43
src/main/java/redis/clients/jedis/JedisCommands.java
View File

@@ -7,8 +7,7 @@ import java.util.Set;
/** /**
* Common interface for sharded and non-sharded Jedis * Common interface for sharded and non-sharded Jedis
*/ */
public interface public interface JedisCommands {
JedisCommands {
String set(String key, String value); String set(String key, String value);
String get(String key); String get(String key);
@@ -114,8 +113,8 @@ public interface
Long strlen(String key); Long strlen(String key);
Long zadd(String key, double score, String member); Long zadd(String key, double score, String member);
Long zadd(String key, Map<Double, String> scoreMembers); Long zadd(String key, Map<String, Double> scoreMembers);
Set<String> zrange(String key, long start, long end); Set<String> zrange(String key, long start, long end);
@@ -152,50 +151,50 @@ public interface
Set<String> zrevrangeByScore(String key, double max, double min); Set<String> zrevrangeByScore(String key, double max, double min);
Set<String> zrangeByScore(String key, double min, double max, int offset, Set<String> zrangeByScore(String key, double min, double max, int offset,
int count); int count);
Set<String> zrevrangeByScore(String key, String max, String min); Set<String> zrevrangeByScore(String key, String max, String min);
Set<String> zrangeByScore(String key, String min, String max, int offset, Set<String> zrangeByScore(String key, String min, String max, int offset,
int count); int count);
Set<String> zrevrangeByScore(String key, double max, double min, Set<String> zrevrangeByScore(String key, double max, double min,
int offset, int count); int offset, int count);
Set<Tuple> zrangeByScoreWithScores(String key, double min, double max); Set<Tuple> zrangeByScoreWithScores(String key, double min, double max);
Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min); Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min);
Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, Set<Tuple> zrangeByScoreWithScores(String key, double min, double max,
int offset, int count); int offset, int count);
Set<String> zrevrangeByScore(String key, String max, String min, Set<String> zrevrangeByScore(String key, String max, String min,
int offset, int count); int offset, int count);
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max); Set<Tuple> zrangeByScoreWithScores(String key, String min, String max);
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min); Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, Set<Tuple> zrangeByScoreWithScores(String key, String min, String max,
int offset, int count); int offset, int count);
Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min,
int offset, int count); int offset, int count);
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min,
int offset, int count); int offset, int count);
Long zremrangeByRank(String key, long start, long end); Long zremrangeByRank(String key, long start, long end);
Long zremrangeByScore(String key, double start, double end); Long zremrangeByScore(String key, double start, double end);
Long zremrangeByScore(String key, String start, String end); Long zremrangeByScore(String key, String start, String end);
Long linsert(String key, Client.LIST_POSITION where, String pivot, Long linsert(String key, Client.LIST_POSITION where, String pivot,
String value); String value);
Long lpushx(String key, String... string); Long lpushx(String key, String... string);
Long rpushx(String key, String... string); Long rpushx(String key, String... string);
List<String> blpop(String arg); List<String> blpop(String arg);
@@ -211,10 +210,10 @@ public interface
Long bitcount(final String key); Long bitcount(final String key);
Long bitcount(final String key, long start, long end); Long bitcount(final String key, long start, long end);
ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor); ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor);
ScanResult<String> sscan(final String key, int cursor); ScanResult<String> sscan(final String key, int cursor);
ScanResult<Tuple> zscan(final String key, int cursor); ScanResult<Tuple> zscan(final String key, int cursor);
} }

12
src/main/java/redis/clients/jedis/JedisMonitor.java
View File

@@ -4,12 +4,12 @@ public abstract class JedisMonitor {
protected Client client; protected Client client;
public void proceed(Client client) { public void proceed(Client client) {
this.client = client; this.client = client;
this.client.setTimeoutInfinite(); this.client.setTimeoutInfinite();
do { do {
String command = client.getBulkReply(); String command = client.getBulkReply();
onCommand(command); onCommand(command);
} while (client.isConnected()); } while (client.isConnected());
} }
public abstract void onCommand(String command); public abstract void onCommand(String command);

3
src/main/java/redis/clients/jedis/JedisPool.java
View File

@@ -18,7 +18,7 @@ public class JedisPool extends Pool<Jedis> {
this(new GenericObjectPoolConfig(), host, port, this(new GenericObjectPoolConfig(), host, port,
Protocol.DEFAULT_TIMEOUT, null, Protocol.DEFAULT_DATABASE, null); Protocol.DEFAULT_TIMEOUT, null, Protocol.DEFAULT_DATABASE, null);
} }
public JedisPool(final String host) { public JedisPool(final String host) {
URI uri = URI.create(host); URI uri = URI.create(host);
if (uri.getScheme() != null && uri.getScheme().equals("redis")) { if (uri.getScheme() != null && uri.getScheme().equals("redis")) {
@@ -84,6 +84,7 @@ public class JedisPool extends Pool<Jedis> {
} }
public void returnResource(final Jedis resource) { public void returnResource(final Jedis resource) {
resource.resetState();
returnResourceObject(resource); returnResourceObject(resource);
} }
} }

10
src/main/java/redis/clients/jedis/JedisPoolConfig.java
View File

@@ -4,10 +4,10 @@ import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
public class JedisPoolConfig extends GenericObjectPoolConfig { public class JedisPoolConfig extends GenericObjectPoolConfig {
public JedisPoolConfig() { public JedisPoolConfig() {
// defaults to make your life with connection pool easier :) // defaults to make your life with connection pool easier :)
setTestWhileIdle(true); setTestWhileIdle(true);
setMinEvictableIdleTimeMillis(60000); setMinEvictableIdleTimeMillis(60000);
setTimeBetweenEvictionRunsMillis(30000); setTimeBetweenEvictionRunsMillis(30000);
setNumTestsPerEvictionRun(-1); setNumTestsPerEvictionRun(-1);
} }
} }

196
src/main/java/redis/clients/jedis/JedisPubSub.java
View File

@@ -16,12 +16,12 @@ import redis.clients.util.SafeEncoder;
public abstract class JedisPubSub { public abstract class JedisPubSub {
private int subscribedChannels = 0; private int subscribedChannels = 0;
private Client client; private volatile Client client;
public abstract void onMessage(String channel, String message); public abstract void onMessage(String channel, String message);
public abstract void onPMessage(String pattern, String channel, public abstract void onPMessage(String pattern, String channel,
String message); String message);
public abstract void onSubscribe(String channel, int subscribedChannels); public abstract void onSubscribe(String channel, int subscribedChannels);
@@ -32,115 +32,145 @@ public abstract class JedisPubSub {
public abstract void onPSubscribe(String pattern, int subscribedChannels); public abstract void onPSubscribe(String pattern, int subscribedChannels);
public void unsubscribe() { public void unsubscribe() {
if (client == null) { if (client == null) {
throw new JedisConnectionException( throw new JedisConnectionException(
"JedisPubSub was not subscribed to a Jedis instance."); "JedisPubSub was not subscribed to a Jedis instance.");
} }
client.unsubscribe(); client.unsubscribe();
client.flush(); client.flush();
} }
public void unsubscribe(String... channels) { public void unsubscribe(String... channels) {
client.unsubscribe(channels); if (client == null) {
client.flush(); throw new JedisConnectionException(
"JedisPubSub is not subscribed to a Jedis instance.");
}
client.unsubscribe(channels);
client.flush();
} }
public void subscribe(String... channels) { public void subscribe(String... channels) {
client.subscribe(channels); if (client == null) {
client.flush(); throw new JedisConnectionException(
"JedisPubSub is not subscribed to a Jedis instance.");
}
client.subscribe(channels);
client.flush();
} }
public void psubscribe(String... patterns) { public void psubscribe(String... patterns) {
client.psubscribe(patterns); if (client == null) {
client.flush(); throw new JedisConnectionException(
"JedisPubSub is not subscribed to a Jedis instance.");
}
client.psubscribe(patterns);
client.flush();
} }
public void punsubscribe() { public void punsubscribe() {
client.punsubscribe(); if (client == null) {
client.flush(); throw new JedisConnectionException(
"JedisPubSub is not subscribed to a Jedis instance.");
}
client.punsubscribe();
client.flush();
} }
public void punsubscribe(String... patterns) { public void punsubscribe(String... patterns) {
client.punsubscribe(patterns); if (client == null) {
client.flush(); throw new JedisConnectionException(
"JedisPubSub is not subscribed to a Jedis instance.");
}
client.punsubscribe(patterns);
client.flush();
} }
public boolean isSubscribed() { public boolean isSubscribed() {
return subscribedChannels > 0; return subscribedChannels > 0;
} }
public void proceedWithPatterns(Client client, String... patterns) { public void proceedWithPatterns(Client client, String... patterns) {
this.client = client; this.client = client;
client.psubscribe(patterns); client.psubscribe(patterns);
client.flush(); client.flush();
process(client); process(client);
} }
public void proceed(Client client, String... channels) { public void proceed(Client client, String... channels) {
this.client = client; this.client = client;
client.subscribe(channels); client.subscribe(channels);
client.flush(); client.flush();
process(client); process(client);
} }
private void process(Client client) { private void process(Client client) {
do {
List<Object> reply = client.getObjectMultiBulkReply(); do {
final Object firstObj = reply.get(0); List<Object> reply = client.getRawObjectMultiBulkReply();
if (!(firstObj instanceof byte[])) { final Object firstObj = reply.get(0);
throw new JedisException("Unknown message type: " + firstObj); if (!(firstObj instanceof byte[])) {
} throw new JedisException("Unknown message type: " + firstObj);
final byte[] resp = (byte[]) firstObj; }
if (Arrays.equals(SUBSCRIBE.raw, resp)) { final byte[] resp = (byte[]) firstObj;
subscribedChannels = ((Long) reply.get(2)).intValue(); if (Arrays.equals(SUBSCRIBE.raw, resp)) {
final byte[] bchannel = (byte[]) reply.get(1); subscribedChannels = ((Long) reply.get(2)).intValue();
final String strchannel = (bchannel == null) ? null final byte[] bchannel = (byte[]) reply.get(1);
: SafeEncoder.encode(bchannel); final String strchannel = (bchannel == null) ? null
onSubscribe(strchannel, subscribedChannels); : SafeEncoder.encode(bchannel);
} else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) { onSubscribe(strchannel, subscribedChannels);
subscribedChannels = ((Long) reply.get(2)).intValue(); } else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) {
final byte[] bchannel = (byte[]) reply.get(1); subscribedChannels = ((Long) reply.get(2)).intValue();
final String strchannel = (bchannel == null) ? null final byte[] bchannel = (byte[]) reply.get(1);
: SafeEncoder.encode(bchannel); final String strchannel = (bchannel == null) ? null
onUnsubscribe(strchannel, subscribedChannels); : SafeEncoder.encode(bchannel);
} else if (Arrays.equals(MESSAGE.raw, resp)) { onUnsubscribe(strchannel, subscribedChannels);
final byte[] bchannel = (byte[]) reply.get(1); } else if (Arrays.equals(MESSAGE.raw, resp)) {
final byte[] bmesg = (byte[]) reply.get(2); final byte[] bchannel = (byte[]) reply.get(1);
final String strchannel = (bchannel == null) ? null final byte[] bmesg = (byte[]) reply.get(2);
: SafeEncoder.encode(bchannel); final String strchannel = (bchannel == null) ? null
final String strmesg = (bmesg == null) ? null : SafeEncoder : SafeEncoder.encode(bchannel);
.encode(bmesg); final String strmesg = (bmesg == null) ? null : SafeEncoder
onMessage(strchannel, strmesg); .encode(bmesg);
} else if (Arrays.equals(PMESSAGE.raw, resp)) { onMessage(strchannel, strmesg);
final byte[] bpattern = (byte[]) reply.get(1); } else if (Arrays.equals(PMESSAGE.raw, resp)) {
final byte[] bchannel = (byte[]) reply.get(2); final byte[] bpattern = (byte[]) reply.get(1);
final byte[] bmesg = (byte[]) reply.get(3); final byte[] bchannel = (byte[]) reply.get(2);
final String strpattern = (bpattern == null) ? null final byte[] bmesg = (byte[]) reply.get(3);
: SafeEncoder.encode(bpattern); final String strpattern = (bpattern == null) ? null
final String strchannel = (bchannel == null) ? null : SafeEncoder.encode(bpattern);
: SafeEncoder.encode(bchannel); final String strchannel = (bchannel == null) ? null
final String strmesg = (bmesg == null) ? null : SafeEncoder : SafeEncoder.encode(bchannel);
.encode(bmesg); final String strmesg = (bmesg == null) ? null : SafeEncoder
onPMessage(strpattern, strchannel, strmesg); .encode(bmesg);
} else if (Arrays.equals(PSUBSCRIBE.raw, resp)) { onPMessage(strpattern, strchannel, strmesg);
subscribedChannels = ((Long) reply.get(2)).intValue(); } else if (Arrays.equals(PSUBSCRIBE.raw, resp)) {
final byte[] bpattern = (byte[]) reply.get(1); subscribedChannels = ((Long) reply.get(2)).intValue();
final String strpattern = (bpattern == null) ? null final byte[] bpattern = (byte[]) reply.get(1);
: SafeEncoder.encode(bpattern); final String strpattern = (bpattern == null) ? null
onPSubscribe(strpattern, subscribedChannels); : SafeEncoder.encode(bpattern);
} else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) { onPSubscribe(strpattern, subscribedChannels);
subscribedChannels = ((Long) reply.get(2)).intValue(); } else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) {
final byte[] bpattern = (byte[]) reply.get(1); subscribedChannels = ((Long) reply.get(2)).intValue();
final String strpattern = (bpattern == null) ? null final byte[] bpattern = (byte[]) reply.get(1);
: SafeEncoder.encode(bpattern); final String strpattern = (bpattern == null) ? null
onPUnsubscribe(strpattern, subscribedChannels); : SafeEncoder.encode(bpattern);
} else { onPUnsubscribe(strpattern, subscribedChannels);
throw new JedisException("Unknown message type: " + firstObj); } else {
} throw new JedisException("Unknown message type: " + firstObj);
} while (isSubscribed()); }
} while (isSubscribed());
/* Invalidate instance since this thread is no longer listening */
this.client = null;
/*
* Reset pipeline count because subscribe() calls would have increased
* it but nothing decremented it.
*/
client.resetPipelinedCount();
} }
public int getSubscribedChannels() { public int getSubscribedChannels() {
return subscribedChannels; return subscribedChannels;
} }
} }

21
src/main/java/redis/clients/jedis/JedisRandomConnectionHandler.java
View File

@@ -4,17 +4,16 @@ import java.util.Set;
public class JedisRandomConnectionHandler extends JedisClusterConnectionHandler { public class JedisRandomConnectionHandler extends JedisClusterConnectionHandler {
public JedisRandomConnectionHandler(Set<HostAndPort> nodes) {
public JedisRandomConnectionHandler(Set<HostAndPort> nodes) { super(nodes);
super(nodes); }
}
public Jedis getConnection() { public Jedis getConnection() {
return getRandomConnection().getResource(); return getRandomConnection().getResource();
} }
@Override @Override
Jedis getConnectionFromSlot(int slot) { Jedis getConnectionFromSlot(int slot) {
return getRandomConnection().getResource(); return getRandomConnection().getResource();
} }
} }

14
src/main/java/redis/clients/jedis/JedisSentinelPool.java
View File

@@ -79,6 +79,7 @@ public class JedisSentinelPool extends Pool<Jedis> {
} }
public void returnResource(final Jedis resource) { public void returnResource(final Jedis resource) {
resource.resetState();
returnResourceObject(resource); returnResourceObject(resource);
} }
@@ -100,8 +101,9 @@ public class JedisSentinelPool extends Pool<Jedis> {
if (!master.equals(currentHostMaster)) { if (!master.equals(currentHostMaster)) {
currentHostMaster = master; currentHostMaster = master;
log.info("Created JedisPool to master at " + master); log.info("Created JedisPool to master at " + master);
initPool(poolConfig, new JedisFactory(master.getHost(), master.getPort(), initPool(poolConfig,
timeout, password, database)); new JedisFactory(master.getHost(), master.getPort(),
timeout, password, database));
} }
} }
@@ -163,10 +165,10 @@ public class JedisSentinelPool extends Pool<Jedis> {
} }
private HostAndPort toHostAndPort(List<String> getMasterAddrByNameResult) { private HostAndPort toHostAndPort(List<String> getMasterAddrByNameResult) {
String host = getMasterAddrByNameResult.get(0); String host = getMasterAddrByNameResult.get(0);
int port = Integer.parseInt(getMasterAddrByNameResult.get(1)); int port = Integer.parseInt(getMasterAddrByNameResult.get(1));
return new HostAndPort(host, port); return new HostAndPort(host, port);
} }
protected class JedisPubSubAdapter extends JedisPubSub { protected class JedisPubSubAdapter extends JedisPubSub {

74
src/main/java/redis/clients/jedis/JedisSlotBasedConnectionHandler.java
View File

@@ -2,47 +2,45 @@ package redis.clients.jedis;
import java.util.Set; import java.util.Set;
public class JedisSlotBasedConnectionHandler extends JedisClusterConnectionHandler { public class JedisSlotBasedConnectionHandler extends
JedisClusterConnectionHandler {
private Jedis currentConnection; private Jedis currentConnection;
public JedisSlotBasedConnectionHandler(Set<HostAndPort> nodes) { public JedisSlotBasedConnectionHandler(Set<HostAndPort> nodes) {
super(nodes); super(nodes);
}
public Jedis getConnection() {
return currentConnection != null ? currentConnection
: getRandomConnection().getResource();
}
private void returnCurrentConnection() {
if (currentConnection != null) {
nodes.get(
currentConnection.getClient().getHost()
+ currentConnection.getClient().getPort())
.returnResource(currentConnection);
} }
}
public Jedis getConnection() {
return currentConnection != null ? currentConnection : getRandomConnection().getResource(); @Override
public void assignSlotToNode(int slot, HostAndPort targetNode) {
super.assignSlotToNode(slot, targetNode);
getConnectionFromSlot(slot);
}
@Override
public Jedis getConnectionFromSlot(int slot) {
returnCurrentConnection();
JedisPool connectionPool = slots.get(slot);
if (connectionPool == null) {
connectionPool = getRandomConnection();
} }
currentConnection = connectionPool.getResource();
return connectionPool.getResource();
}
private void returnCurrentConnection() {
if (currentConnection != null) {
nodes.get(currentConnection.getClient().getHost()+currentConnection.getClient().getPort()).returnResource(currentConnection);
}
}
@Override
public void assignSlotToNode(int slot, HostAndPort targetNode) {
super.assignSlotToNode(slot, targetNode);
getConnectionFromSlot(slot);
}
@Override
public Jedis getConnectionFromSlot(int slot) {
returnCurrentConnection();
JedisPool connectionPool = slots.get(slot);
if (connectionPool == null) {
connectionPool = getRandomConnection();
}
currentConnection = connectionPool.getResource();
return connectionPool.getResource();
}
} }

1
src/main/java/redis/clients/jedis/MultiKeyBinaryCommands.java
View File

@@ -1,6 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;

9
src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
View File

@@ -1,16 +1,16 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
/** /**
* Multikey related commands (these are split out because they are non-shardable) * Multikey related commands (these are split out because they are
* non-shardable)
*/ */
public interface MultiKeyBinaryRedisPipeline { public interface MultiKeyBinaryRedisPipeline {
Response<Long> del(byte[]... keys); Response<Long> del(byte[]... keys);
Response<List<byte[]>> blpop(byte[]... args); Response<List<byte[]>> blpop(byte[]... args);
Response<List<byte[]>> brpop(byte[]... args); Response<List<byte[]>> brpop(byte[]... args);
@@ -39,7 +39,8 @@ public interface MultiKeyBinaryRedisPipeline {
Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member); Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member);
Response<Long> sort(byte[] key, SortingParams sortingParameters, byte[] dstkey); Response<Long> sort(byte[] key, SortingParams sortingParameters,
byte[] dstkey);
Response<Long> sort(byte[] key, byte[] dstkey); Response<Long> sort(byte[] key, byte[] dstkey);

4
src/main/java/redis/clients/jedis/MultiKeyCommands.java
View File

@@ -1,8 +1,6 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Set; import java.util.Set;
public interface MultiKeyCommands { public interface MultiKeyCommands {
@@ -71,6 +69,6 @@ public interface MultiKeyCommands {
String randomKey(); String randomKey();
Long bitop(BitOP op, final String destKey, String... srcKeys); Long bitop(BitOP op, final String destKey, String... srcKeys);
ScanResult<String> scan(int cursor); ScanResult<String> scan(int cursor);
} }

8
src/main/java/redis/clients/jedis/MultiKeyCommandsPipeline.java
View File

@@ -1,12 +1,11 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
/** /**
* Multikey related commands (these are split out because they are non-shardable) * Multikey related commands (these are split out because they are
* non-shardable)
*/ */
public interface MultiKeyCommandsPipeline { public interface MultiKeyCommandsPipeline {
Response<Long> del(String... keys); Response<Long> del(String... keys);
@@ -39,7 +38,8 @@ public interface MultiKeyCommandsPipeline {
Response<Long> smove(String srckey, String dstkey, String member); Response<Long> smove(String srckey, String dstkey, String member);
Response<Long> sort(String key, SortingParams sortingParameters, String dstkey); Response<Long> sort(String key, SortingParams sortingParameters,
String dstkey);
Response<Long> sort(String key, String dstkey); Response<Long> sort(String key, String dstkey);

356
src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java
View File

@@ -5,401 +5,399 @@ import java.util.Map;
import java.util.Set; import java.util.Set;
abstract class MultiKeyPipelineBase extends PipelineBase implements abstract class MultiKeyPipelineBase extends PipelineBase implements
BasicRedisPipeline, BasicRedisPipeline, MultiKeyBinaryRedisPipeline,
MultiKeyBinaryRedisPipeline, MultiKeyCommandsPipeline, ClusterPipeline {
MultiKeyCommandsPipeline,
ClusterPipeline {
protected Client client = null; protected Client client = null;
public Response<List<String>> brpop(String... args) { public Response<List<String>> brpop(String... args) {
client.brpop(args); client.brpop(args);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<List<String>> brpop(int timeout, String... keys) { public Response<List<String>> brpop(int timeout, String... keys) {
client.brpop(timeout, keys); client.brpop(timeout, keys);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<List<String>> blpop(String... args) { public Response<List<String>> blpop(String... args) {
client.blpop(args); client.blpop(args);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<List<String>> blpop(int timeout, String... keys) { public Response<List<String>> blpop(int timeout, String... keys) {
client.blpop(timeout, keys); client.blpop(timeout, keys);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<Map<String, String>> blpopMap(int timeout, String... keys) { public Response<Map<String, String>> blpopMap(int timeout, String... keys) {
client.blpop(timeout, keys); client.blpop(timeout, keys);
return getResponse(BuilderFactory.STRING_MAP); return getResponse(BuilderFactory.STRING_MAP);
} }
public Response<List<byte[]>> brpop(byte[]... args) { public Response<List<byte[]>> brpop(byte[]... args) {
client.brpop(args); client.brpop(args);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST); return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
} }
public Response<List<String>> brpop(int timeout, byte[]... keys) { public Response<List<String>> brpop(int timeout, byte[]... keys) {
client.brpop(timeout, keys); client.brpop(timeout, keys);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<Map<String, String>> brpopMap(int timeout, String... keys) { public Response<Map<String, String>> brpopMap(int timeout, String... keys) {
client.blpop(timeout, keys); client.blpop(timeout, keys);
return getResponse(BuilderFactory.STRING_MAP); return getResponse(BuilderFactory.STRING_MAP);
} }
public Response<List<byte[]>> blpop(byte[]... args) { public Response<List<byte[]>> blpop(byte[]... args) {
client.blpop(args); client.blpop(args);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST); return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
} }
public Response<List<String>> blpop(int timeout, byte[]... keys) { public Response<List<String>> blpop(int timeout, byte[]... keys) {
client.blpop(timeout, keys); client.blpop(timeout, keys);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<Long> del(String... keys) { public Response<Long> del(String... keys) {
client.del(keys); client.del(keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> del(byte[]... keys) { public Response<Long> del(byte[]... keys) {
client.del(keys); client.del(keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Set<String>> keys(String pattern) { public Response<Set<String>> keys(String pattern) {
getClient(pattern).keys(pattern); getClient(pattern).keys(pattern);
return getResponse(BuilderFactory.STRING_SET); return getResponse(BuilderFactory.STRING_SET);
} }
public Response<Set<byte[]>> keys(byte[] pattern) { public Response<Set<byte[]>> keys(byte[] pattern) {
getClient(pattern).keys(pattern); getClient(pattern).keys(pattern);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET); return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
} }
public Response<List<String>> mget(String... keys) { public Response<List<String>> mget(String... keys) {
client.mget(keys); client.mget(keys);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<List<byte[]>> mget(byte[]... keys) { public Response<List<byte[]>> mget(byte[]... keys) {
client.mget(keys); client.mget(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST); return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
} }
public Response<String> mset(String... keysvalues) { public Response<String> mset(String... keysvalues) {
client.mset(keysvalues); client.mset(keysvalues);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> mset(byte[]... keysvalues) { public Response<String> mset(byte[]... keysvalues) {
client.mset(keysvalues); client.mset(keysvalues);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> msetnx(String... keysvalues) { public Response<Long> msetnx(String... keysvalues) {
client.msetnx(keysvalues); client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> msetnx(byte[]... keysvalues) { public Response<Long> msetnx(byte[]... keysvalues) {
client.msetnx(keysvalues); client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> rename(String oldkey, String newkey) { public Response<String> rename(String oldkey, String newkey) {
client.rename(oldkey, newkey); client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> rename(byte[] oldkey, byte[] newkey) { public Response<String> rename(byte[] oldkey, byte[] newkey) {
client.rename(oldkey, newkey); client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> renamenx(String oldkey, String newkey) { public Response<Long> renamenx(String oldkey, String newkey) {
client.renamenx(oldkey, newkey); client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> renamenx(byte[] oldkey, byte[] newkey) { public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
client.renamenx(oldkey, newkey); client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> rpoplpush(String srckey, String dstkey) { public Response<String> rpoplpush(String srckey, String dstkey) {
client.rpoplpush(srckey, dstkey); client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) { public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
client.rpoplpush(srckey, dstkey); client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.BYTE_ARRAY); return getResponse(BuilderFactory.BYTE_ARRAY);
} }
public Response<Set<String>> sdiff(String... keys) { public Response<Set<String>> sdiff(String... keys) {
client.sdiff(keys); client.sdiff(keys);
return getResponse(BuilderFactory.STRING_SET); return getResponse(BuilderFactory.STRING_SET);
} }
public Response<Set<byte[]>> sdiff(byte[]... keys) { public Response<Set<byte[]>> sdiff(byte[]... keys) {
client.sdiff(keys); client.sdiff(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET); return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
} }
public Response<Long> sdiffstore(String dstkey, String... keys) { public Response<Long> sdiffstore(String dstkey, String... keys) {
client.sdiffstore(dstkey, keys); client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) { public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
client.sdiffstore(dstkey, keys); client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Set<String>> sinter(String... keys) { public Response<Set<String>> sinter(String... keys) {
client.sinter(keys); client.sinter(keys);
return getResponse(BuilderFactory.STRING_SET); return getResponse(BuilderFactory.STRING_SET);
} }
public Response<Set<byte[]>> sinter(byte[]... keys) { public Response<Set<byte[]>> sinter(byte[]... keys) {
client.sinter(keys); client.sinter(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET); return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
} }
public Response<Long> sinterstore(String dstkey, String... keys) { public Response<Long> sinterstore(String dstkey, String... keys) {
client.sinterstore(dstkey, keys); client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) { public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
client.sinterstore(dstkey, keys); client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> smove(String srckey, String dstkey, String member) { public Response<Long> smove(String srckey, String dstkey, String member) {
client.smove(srckey, dstkey, member); client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) { public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
client.smove(srckey, dstkey, member); client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sort(String key, public Response<Long> sort(String key, SortingParams sortingParameters,
SortingParams sortingParameters, String dstkey) { String dstkey) {
client.sort(key, sortingParameters, dstkey); client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sort(byte[] key, public Response<Long> sort(byte[] key, SortingParams sortingParameters,
SortingParams sortingParameters, byte[] dstkey) { byte[] dstkey) {
client.sort(key, sortingParameters, dstkey); client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sort(String key, String dstkey) { public Response<Long> sort(String key, String dstkey) {
client.sort(key, dstkey); client.sort(key, dstkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sort(byte[] key, byte[] dstkey) { public Response<Long> sort(byte[] key, byte[] dstkey) {
client.sort(key, dstkey); client.sort(key, dstkey);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Set<String>> sunion(String... keys) { public Response<Set<String>> sunion(String... keys) {
client.sunion(keys); client.sunion(keys);
return getResponse(BuilderFactory.STRING_SET); return getResponse(BuilderFactory.STRING_SET);
} }
public Response<Set<byte[]>> sunion(byte[]... keys) { public Response<Set<byte[]>> sunion(byte[]... keys) {
client.sunion(keys); client.sunion(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET); return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
} }
public Response<Long> sunionstore(String dstkey, String... keys) { public Response<Long> sunionstore(String dstkey, String... keys) {
client.sunionstore(dstkey, keys); client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) { public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
client.sunionstore(dstkey, keys); client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> watch(String... keys) { public Response<String> watch(String... keys) {
client.watch(keys); client.watch(keys);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> watch(byte[]... keys) { public Response<String> watch(byte[]... keys) {
client.watch(keys); client.watch(keys);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> zinterstore(String dstkey, String... sets) { public Response<Long> zinterstore(String dstkey, String... sets) {
client.zinterstore(dstkey, sets); client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) { public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
client.zinterstore(dstkey, sets); client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zinterstore(String dstkey, ZParams params, public Response<Long> zinterstore(String dstkey, ZParams params,
String... sets) { String... sets) {
client.zinterstore(dstkey, params, sets); client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zinterstore(byte[] dstkey, ZParams params, public Response<Long> zinterstore(byte[] dstkey, ZParams params,
byte[]... sets) { byte[]... sets) {
client.zinterstore(dstkey, params, sets); client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zunionstore(String dstkey, String... sets) { public Response<Long> zunionstore(String dstkey, String... sets) {
client.zunionstore(dstkey, sets); client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) { public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
client.zunionstore(dstkey, sets); client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zunionstore(String dstkey, ZParams params, public Response<Long> zunionstore(String dstkey, ZParams params,
String... sets) { String... sets) {
client.zunionstore(dstkey, params, sets); client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> zunionstore(byte[] dstkey, ZParams params, public Response<Long> zunionstore(byte[] dstkey, ZParams params,
byte[]... sets) { byte[]... sets) {
client.zunionstore(dstkey, params, sets); client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> bgrewriteaof() { public Response<String> bgrewriteaof() {
client.bgrewriteaof(); client.bgrewriteaof();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> bgsave() { public Response<String> bgsave() {
client.bgsave(); client.bgsave();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> configGet(String pattern) { public Response<String> configGet(String pattern) {
client.configGet(pattern); client.configGet(pattern);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> configSet(String parameter, String value) { public Response<String> configSet(String parameter, String value) {
client.configSet(parameter, value); client.configSet(parameter, value);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> brpoplpush(String source, String destination, public Response<String> brpoplpush(String source, String destination,
int timeout) { int timeout) {
client.brpoplpush(source, destination, timeout); client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<byte[]> brpoplpush(byte[] source, byte[] destination, public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
int timeout) { int timeout) {
client.brpoplpush(source, destination, timeout); client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.BYTE_ARRAY); return getResponse(BuilderFactory.BYTE_ARRAY);
} }
public Response<String> configResetStat() { public Response<String> configResetStat() {
client.configResetStat(); client.configResetStat();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> save() { public Response<String> save() {
client.save(); client.save();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> lastsave() { public Response<Long> lastsave() {
client.lastsave(); client.lastsave();
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> publish(String channel, String message) { public Response<Long> publish(String channel, String message) {
client.publish(channel, message); client.publish(channel, message);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> publish(byte[] channel, byte[] message) { public Response<Long> publish(byte[] channel, byte[] message) {
client.publish(channel, message); client.publish(channel, message);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> randomKey() { public Response<String> randomKey() {
client.randomKey(); client.randomKey();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<byte[]> randomKeyBinary() { public Response<byte[]> randomKeyBinary() {
client.randomKey(); client.randomKey();
return getResponse(BuilderFactory.BYTE_ARRAY); return getResponse(BuilderFactory.BYTE_ARRAY);
} }
public Response<String> flushDB() { public Response<String> flushDB() {
client.flushDB(); client.flushDB();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> flushAll() { public Response<String> flushAll() {
client.flushAll(); client.flushAll();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> info() { public Response<String> info() {
client.info(); client.info();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> dbSize() { public Response<Long> dbSize() {
client.dbSize(); client.dbSize();
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> shutdown() { public Response<String> shutdown() {
client.shutdown(); client.shutdown();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> ping() { public Response<String> ping() {
client.ping(); client.ping();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> select(int index) { public Response<String> select(int index) {
client.select(index); client.select(index);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<Long> bitop(BitOP op, byte[] destKey, byte[]... srcKeys) { public Response<Long> bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
client.bitop(op, destKey, srcKeys); client.bitop(op, destKey, srcKeys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<Long> bitop(BitOP op, String destKey, String... srcKeys) { public Response<Long> bitop(BitOP op, String destKey, String... srcKeys) {
client.bitop(op, destKey, srcKeys); client.bitop(op, destKey, srcKeys);
return getResponse(BuilderFactory.LONG); return getResponse(BuilderFactory.LONG);
} }
public Response<String> clusterNodes() { public Response<String> clusterNodes() {
client.clusterNodes(); client.clusterNodes();
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
@@ -425,22 +423,26 @@ abstract class MultiKeyPipelineBase extends PipelineBase implements
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<List<String>> clusterGetKeysInSlot(final int slot, final int count) { public Response<List<String>> clusterGetKeysInSlot(final int slot,
final int count) {
client.clusterGetKeysInSlot(slot, count); client.clusterGetKeysInSlot(slot, count);
return getResponse(BuilderFactory.STRING_LIST); return getResponse(BuilderFactory.STRING_LIST);
} }
public Response<String> clusterSetSlotNode(final int slot, final String nodeId) { public Response<String> clusterSetSlotNode(final int slot,
final String nodeId) {
client.clusterSetSlotNode(slot, nodeId); client.clusterSetSlotNode(slot, nodeId);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> clusterSetSlotMigrating(final int slot, final String nodeId) { public Response<String> clusterSetSlotMigrating(final int slot,
final String nodeId) {
client.clusterSetSlotMigrating(slot, nodeId); client.clusterSetSlotMigrating(slot, nodeId);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<String> clusterSetSlotImporting(final int slot, final String nodeId) { public Response<String> clusterSetSlotImporting(final int slot,
final String nodeId) {
client.clusterSetSlotImporting(slot, nodeId); client.clusterSetSlotImporting(slot, nodeId);
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }

137
src/main/java/redis/clients/jedis/Pipeline.java
View File

@@ -1,66 +1,66 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.jedis.exceptions.JedisDataException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class Pipeline extends MultiKeyPipelineBase { import redis.clients.jedis.exceptions.JedisDataException;
private MultiResponseBuilder currentMulti;
private class MultiResponseBuilder extends Builder<List<Object>>{
private List<Response<?>> responses = new ArrayList<Response<?>>();
@Override
public List<Object> build(Object data) {
@SuppressWarnings("unchecked")
List<Object> list = (List<Object>)data;
List<Object> values = new ArrayList<Object>();
if(list.size() != responses.size()){
throw new JedisDataException("Expected data size " + responses.size() + " but was " + list.size());
}
for(int i=0;i<list.size();i++){
Response<?> response = responses.get(i);
response.set(list.get(i));
values.add(response.get());
}
return values;
}
public void addResponse(Response<?> response){ public class Pipeline extends MultiKeyPipelineBase {
responses.add(response);
} private MultiResponseBuilder currentMulti;
private class MultiResponseBuilder extends Builder<List<Object>> {
private List<Response<?>> responses = new ArrayList<Response<?>>();
@Override
public List<Object> build(Object data) {
@SuppressWarnings("unchecked")
List<Object> list = (List<Object>) data;
List<Object> values = new ArrayList<Object>();
if (list.size() != responses.size()) {
throw new JedisDataException("Expected data size "
+ responses.size() + " but was " + list.size());
}
for (int i = 0; i < list.size(); i++) {
Response<?> response = responses.get(i);
response.set(list.get(i));
values.add(response.get());
}
return values;
}
public void addResponse(Response<?> response) {
responses.add(response);
}
} }
@Override @Override
protected <T> Response<T> getResponse(Builder<T> builder) { protected <T> Response<T> getResponse(Builder<T> builder) {
if(currentMulti != null){ if (currentMulti != null) {
super.getResponse(BuilderFactory.STRING); //Expected QUEUED super.getResponse(BuilderFactory.STRING); // Expected QUEUED
Response<T> lr = new Response<T>(builder); Response<T> lr = new Response<T>(builder);
currentMulti.addResponse(lr); currentMulti.addResponse(lr);
return lr; return lr;
} } else {
else{ return super.getResponse(builder);
return super.getResponse(builder); }
}
} }
public void setClient(Client client) { public void setClient(Client client) {
this.client = client; this.client = client;
} }
@Override @Override
protected Client getClient(byte[] key) { protected Client getClient(byte[] key) {
return client; return client;
} }
@Override @Override
protected Client getClient(String key) { protected Client getClient(String key) {
return client; return client;
} }
/** /**
@@ -69,10 +69,10 @@ public class Pipeline extends MultiKeyPipelineBase {
* the different Response<?> of the commands you execute. * the different Response<?> of the commands you execute.
*/ */
public void sync() { public void sync() {
List<Object> unformatted = client.getAll(); List<Object> unformatted = client.getAll();
for (Object o : unformatted) { for (Object o : unformatted) {
generateResponse(o); generateResponse(o);
} }
} }
/** /**
@@ -84,37 +84,38 @@ public class Pipeline extends MultiKeyPipelineBase {
* @return A list of all the responses in the order you executed them. * @return A list of all the responses in the order you executed them.
*/ */
public List<Object> syncAndReturnAll() { public List<Object> syncAndReturnAll() {
List<Object> unformatted = client.getAll(); List<Object> unformatted = client.getAll();
List<Object> formatted = new ArrayList<Object>(); List<Object> formatted = new ArrayList<Object>();
for (Object o : unformatted) { for (Object o : unformatted) {
try { try {
formatted.add(generateResponse(o).get()); formatted.add(generateResponse(o).get());
} catch (JedisDataException e) { } catch (JedisDataException e) {
formatted.add(e); formatted.add(e);
} }
} }
return formatted; return formatted;
} }
public Response<String> discard() { public Response<String> discard() {
client.discard(); client.discard();
currentMulti = null; currentMulti = null;
return getResponse(BuilderFactory.STRING); return getResponse(BuilderFactory.STRING);
} }
public Response<List<Object>> exec() { public Response<List<Object>> exec() {
client.exec(); client.exec();
Response<List<Object>> response = super.getResponse(currentMulti); Response<List<Object>> response = super.getResponse(currentMulti);
currentMulti = null; currentMulti = null;
return response; return response;
} }
public Response<String> multi() { public Response<String> multi() {
client.multi(); client.multi();
Response<String> response = getResponse(BuilderFactory.STRING); //Expecting OK Response<String> response = getResponse(BuilderFactory.STRING); // Expecting
currentMulti = new MultiResponseBuilder(); // OK
return response; currentMulti = new MultiResponseBuilder();
return response;
} }
} }

1190
src/main/java/redis/clients/jedis/PipelineBase.java
View File

File diff suppressed because it is too large Load Diff

1
src/main/java/redis/clients/jedis/PipelineBlock.java
View File

@@ -1,6 +1,5 @@
package redis.clients.jedis; package redis.clients.jedis;
public abstract class PipelineBlock extends Pipeline { public abstract class PipelineBlock extends Pipeline {
public abstract void execute(); public abstract void execute();
} }

66
src/main/java/redis/clients/jedis/Protocol.java
View File

@@ -16,7 +16,7 @@ public final class Protocol {
private static final String ASK_RESPONSE = "ASK"; private static final String ASK_RESPONSE = "ASK";
private static final String MOVED_RESPONSE = "MOVED"; private static final String MOVED_RESPONSE = "MOVED";
public static final int DEFAULT_PORT = 6379; public static final int DEFAULT_PORT = 6379;
public static final int DEFAULT_SENTINEL_PORT = 26379; public static final int DEFAULT_SENTINEL_PORT = 26379;
public static final int DEFAULT_TIMEOUT = 2000; public static final int DEFAULT_TIMEOUT = 2000;
public static final int DEFAULT_DATABASE = 0; public static final int DEFAULT_DATABASE = 0;
@@ -48,7 +48,10 @@ public final class Protocol {
public static final String CLUSTER_SETSLOT_NODE = "node"; public static final String CLUSTER_SETSLOT_NODE = "node";
public static final String CLUSTER_SETSLOT_MIGRATING = "migrating"; public static final String CLUSTER_SETSLOT_MIGRATING = "migrating";
public static final String CLUSTER_SETSLOT_IMPORTING = "importing"; public static final String CLUSTER_SETSLOT_IMPORTING = "importing";
public static final String PUBSUB_CHANNELS= "channels";
public static final String PUBSUB_NUMSUB = "numsub";
public static final String PUBSUB_NUM_PAT = "numpat";
private Protocol() { private Protocol() {
// this prevent the class from instantiation // this prevent the class from instantiation
} }
@@ -80,27 +83,32 @@ public final class Protocol {
} }
private static void processError(final RedisInputStream is) { private static void processError(final RedisInputStream is) {
String message = is.readLine(); String message = is.readLine();
//TODO: I'm not sure if this is the best way to do this. // TODO: I'm not sure if this is the best way to do this.
//Maybe Read only first 5 bytes instead? // Maybe Read only first 5 bytes instead?
if (message.startsWith(MOVED_RESPONSE)) { if (message.startsWith(MOVED_RESPONSE)) {
String[] movedInfo = parseTargetHostAndSlot(message); String[] movedInfo = parseTargetHostAndSlot(message);
throw new JedisMovedDataException(message, new HostAndPort(movedInfo[1], Integer.valueOf(movedInfo[2])), Integer.valueOf(movedInfo[0])); throw new JedisMovedDataException(message, new HostAndPort(
} else if (message.startsWith(ASK_RESPONSE)) { movedInfo[1], Integer.valueOf(movedInfo[2])),
String[] askInfo = parseTargetHostAndSlot(message); Integer.valueOf(movedInfo[0]));
throw new JedisAskDataException(message, new HostAndPort(askInfo[1], Integer.valueOf(askInfo[2])), Integer.valueOf(askInfo[0])); } else if (message.startsWith(ASK_RESPONSE)) {
} String[] askInfo = parseTargetHostAndSlot(message);
throw new JedisDataException(message); throw new JedisAskDataException(message, new HostAndPort(
askInfo[1], Integer.valueOf(askInfo[2])),
Integer.valueOf(askInfo[0]));
}
throw new JedisDataException(message);
} }
private static String[] parseTargetHostAndSlot(String clusterRedirectResponse) { private static String[] parseTargetHostAndSlot(
String[] response = new String[3]; String clusterRedirectResponse) {
String[] messageInfo = clusterRedirectResponse.split(" "); String[] response = new String[3];
String[] targetHostAndPort = messageInfo[2].split(":"); String[] messageInfo = clusterRedirectResponse.split(" ");
response[0] = messageInfo[1]; String[] targetHostAndPort = messageInfo[2].split(":");
response[1] = targetHostAndPort[0]; response[0] = messageInfo[1];
response[2] = targetHostAndPort[1]; response[1] = targetHostAndPort[0];
return response; response[2] = targetHostAndPort[1];
return response;
} }
private static Object process(final RedisInputStream is) { private static Object process(final RedisInputStream is) {
@@ -138,10 +146,11 @@ public final class Protocol {
int offset = 0; int offset = 0;
try { try {
while (offset < len) { while (offset < len) {
int size = is.read(read, offset, (len - offset)); int size = is.read(read, offset, (len - offset));
if (size == -1) if (size == -1)
throw new JedisConnectionException("It seems like server has closed the connection."); throw new JedisConnectionException(
offset += size; "It seems like server has closed the connection.");
offset += size;
} }
// read 2 more bytes for the command delimiter // read 2 more bytes for the command delimiter
is.readByte(); is.readByte();
@@ -195,7 +204,7 @@ public final class Protocol {
} }
public static enum Command { public static enum Command {
PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL, DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT, SCAN, HSCAN, SSCAN, ZSCAN, WAIT, CLUSTER, ASKING; PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBSUB, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL, DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT, SCAN, HSCAN, SSCAN, ZSCAN, WAIT, CLUSTER, ASKING;
public final byte[] raw; public final byte[] raw;
@@ -205,8 +214,7 @@ public final class Protocol {
} }
public static enum Keyword { public static enum Keyword {
AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME, AND, OR, XOR, NOT, AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME, AND, OR, XOR, NOT, GETNAME, SETNAME, LIST, MATCH, COUNT;
GETNAME, SETNAME,LIST, MATCH, COUNT;
public final byte[] raw; public final byte[] raw;
Keyword() { Keyword() {

18
src/main/java/redis/clients/jedis/Queable.java
View File

@@ -7,21 +7,21 @@ public class Queable {
private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>(); private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>();
protected void clean() { protected void clean() {
pipelinedResponses.clear(); pipelinedResponses.clear();
} }
protected Response<?> generateResponse(Object data) { protected Response<?> generateResponse(Object data) {
Response<?> response = pipelinedResponses.poll(); Response<?> response = pipelinedResponses.poll();
if (response != null) { if (response != null) {
response.set(data); response.set(data);
} }
return response; return response;
} }
protected <T> Response<T> getResponse(Builder<T> builder) { protected <T> Response<T> getResponse(Builder<T> builder) {
Response<T> lr = new Response<T>(builder); Response<T> lr = new Response<T>(builder);
pipelinedResponses.add(lr); pipelinedResponses.add(lr);
return lr; return lr;
} }
} }

45
src/main/java/redis/clients/jedis/RedisPipeline.java
View File

@@ -32,10 +32,7 @@ public interface RedisPipeline {
Response<Boolean> getbit(String key, long offset); Response<Boolean> getbit(String key, long offset);
Response<String> getrange(String key, long startOffset, long endOffset);
Response<String> getrange(String key, long startOffset,
long endOffset);
Response<String> getSet(String key, String value); Response<String> getSet(String key, String value);
@@ -70,7 +67,7 @@ public interface RedisPipeline {
Response<String> lindex(String key, long index); Response<String> lindex(String key, long index);
Response<Long> linsert(String key, BinaryClient.LIST_POSITION where, Response<Long> linsert(String key, BinaryClient.LIST_POSITION where,
String pivot, String value); String pivot, String value);
Response<Long> llen(String key); Response<Long> llen(String key);
@@ -118,8 +115,7 @@ public interface RedisPipeline {
Response<List<String>> sort(String key); Response<List<String>> sort(String key);
Response<List<String>> sort(String key, Response<List<String>> sort(String key, SortingParams sortingParameters);
SortingParams sortingParameters);
Response<String> spop(String key); Response<String> spop(String key);
@@ -145,35 +141,31 @@ public interface RedisPipeline {
Response<Set<String>> zrange(String key, long start, long end); Response<Set<String>> zrange(String key, long start, long end);
Response<Set<String>> zrangeByScore(String key, double min, Response<Set<String>> zrangeByScore(String key, double min, double max);
double max);
Response<Set<String>> zrangeByScore(String key, String min, Response<Set<String>> zrangeByScore(String key, String min, String max);
String max);
Response<Set<String>> zrangeByScore(String key, double min, Response<Set<String>> zrangeByScore(String key, double min, double max,
double max, int offset, int count); int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max); double max);
Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count); double max, int offset, int count);
Response<Set<String>> zrevrangeByScore(String key, double max, Response<Set<String>> zrevrangeByScore(String key, double max, double min);
double min);
Response<Set<String>> zrevrangeByScore(String key, String max, Response<Set<String>> zrevrangeByScore(String key, String max, String min);
String min);
Response<Set<String>> zrevrangeByScore(String key, double max, Response<Set<String>> zrevrangeByScore(String key, double max, double min,
double min, int offset, int count); int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max,
double max, double min); double min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max,
double max, double min, int offset, int count); double min, int offset, int count);
Response<Set<Tuple>> zrangeWithScores(String key, long start, long end); Response<Set<Tuple>> zrangeWithScores(String key, long start, long end);
@@ -187,8 +179,7 @@ public interface RedisPipeline {
Response<Set<String>> zrevrange(String key, long start, long end); Response<Set<String>> zrevrange(String key, long start, long end);
Response<Set<Tuple>> zrevrangeWithScores(String key, long start, Response<Set<Tuple>> zrevrangeWithScores(String key, long start, long end);
long end);
Response<Long> zrevrank(String key, String member); Response<Long> zrevrank(String key, String member);

38
src/main/java/redis/clients/jedis/Response.java
View File

@@ -10,34 +10,34 @@ public class Response<T> {
private Object data; private Object data;
public Response(Builder<T> b) { public Response(Builder<T> b) {
this.builder = b; this.builder = b;
} }
public void set(Object data) { public void set(Object data) {
this.data = data; this.data = data;
set = true; set = true;
} }
public T get() { public T get() {
if (!set) { if (!set) {
throw new JedisDataException( throw new JedisDataException(
"Please close pipeline or multi block before calling this method."); "Please close pipeline or multi block before calling this method.");
} }
if (!built) { if (!built) {
if(data != null ){ if (data != null) {
if (data instanceof JedisDataException){ if (data instanceof JedisDataException) {
throw new JedisDataException((JedisDataException)data); throw new JedisDataException((JedisDataException) data);
} }
response = builder.build(data); response = builder.build(data);
} }
this.data = null; this.data = null;
built = true; built = true;
} }
return response; return response;
} }
public String toString() { public String toString() {
return "Response " + builder.toString(); return "Response " + builder.toString();
} }
} }

40
src/main/java/redis/clients/jedis/ShardedJedis.java
View File

@@ -1,14 +1,14 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.Set; import java.util.Set;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
public class ShardedJedis extends BinaryShardedJedis implements JedisCommands { public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
public ShardedJedis(List<JedisShardInfo> shards) { public ShardedJedis(List<JedisShardInfo> shards) {
super(shards); super(shards);
@@ -38,8 +38,8 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
} }
public String echo(String string) { public String echo(String string) {
Jedis j = getShard(string); Jedis j = getShard(string);
return j.echo(string); return j.echo(string);
} }
public Boolean exists(String key) { public Boolean exists(String key) {
@@ -73,8 +73,8 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
} }
public Boolean setbit(String key, long offset, String value) { public Boolean setbit(String key, long offset, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.setbit(key, offset, value); return j.setbit(key, offset, value);
} }
public Boolean getbit(String key, long offset) { public Boolean getbit(String key, long offset) {
@@ -108,13 +108,13 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
} }
public List<String> blpop(String arg) { public List<String> blpop(String arg) {
Jedis j = getShard(arg); Jedis j = getShard(arg);
return j.blpop(arg); return j.blpop(arg);
} }
public List<String> brpop(String arg) { public List<String> brpop(String arg) {
Jedis j = getShard(arg); Jedis j = getShard(arg);
return j.brpop(arg); return j.brpop(arg);
} }
public Long decrBy(String key, long integer) { public Long decrBy(String key, long integer) {
@@ -228,13 +228,13 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
} }
public Long strlen(final String key) { public Long strlen(final String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.strlen(key); return j.strlen(key);
} }
public Long move(String key, int dbIndex) { public Long move(String key, int dbIndex) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.move(key, dbIndex); return j.move(key, dbIndex);
} }
public Long rpushx(String key, String... string) { public Long rpushx(String key, String... string) {
@@ -243,8 +243,8 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
} }
public Long persist(final String key) { public Long persist(final String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.persist(key); return j.persist(key);
} }
public Long llen(String key) { public Long llen(String key) {
@@ -327,7 +327,7 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.zadd(key, score, member); return j.zadd(key, score, member);
} }
public Long zadd(String key, Map<Double, String> scoreMembers) { public Long zadd(String key, Map<String, Double> scoreMembers) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zadd(key, scoreMembers); return j.zadd(key, scoreMembers);
} }
@@ -527,12 +527,12 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hscan(key, cursor); return j.hscan(key, cursor);
} }
public ScanResult<String> sscan(String key, int cursor) { public ScanResult<String> sscan(String key, int cursor) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.sscan(key, cursor); return j.sscan(key, cursor);
} }
public ScanResult<Tuple> zscan(String key, int cursor) { public ScanResult<Tuple> zscan(String key, int cursor) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zscan(key, cursor); return j.zscan(key, cursor);

68
src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
View File

@@ -11,27 +11,27 @@ public class ShardedJedisPipeline extends PipelineBase {
private Queue<Client> clients = new LinkedList<Client>(); private Queue<Client> clients = new LinkedList<Client>();
private static class FutureResult { private static class FutureResult {
private Client client; private Client client;
public FutureResult(Client client) { public FutureResult(Client client) {
this.client = client; this.client = client;
} }
public Object get() { public Object get() {
return client.getOne(); return client.getOne();
} }
} }
public void setShardedJedis(BinaryShardedJedis jedis) { public void setShardedJedis(BinaryShardedJedis jedis) {
this.jedis = jedis; this.jedis = jedis;
} }
public List<Object> getResults() { public List<Object> getResults() {
List<Object> r = new ArrayList<Object>(); List<Object> r = new ArrayList<Object>();
for (FutureResult fr : results) { for (FutureResult fr : results) {
r.add(fr.get()); r.add(fr.get());
} }
return r; return r;
} }
/** /**
@@ -40,30 +40,30 @@ public class ShardedJedisPipeline extends PipelineBase {
* the different Response&lt;?&gt; of the commands you execute. * the different Response&lt;?&gt; of the commands you execute.
*/ */
public void sync() { public void sync() {
for (Client client : clients) { for (Client client : clients) {
generateResponse(client.getOne()); generateResponse(client.getOne());
} }
} }
/** /**
* Syncronize pipeline by reading all responses. This operation closes the * Syncronize pipeline by reading all responses. This operation closes the
* pipeline. Whenever possible try to avoid using this version and use * pipeline. Whenever possible try to avoid using this version and use
* ShardedJedisPipeline.sync() as it won't go through all the responses and generate the * ShardedJedisPipeline.sync() as it won't go through all the responses and
* right response type (usually it is a waste of time). * generate the right response type (usually it is a waste of time).
* *
* @return A list of all the responses in the order you executed them. * @return A list of all the responses in the order you executed them.
*/ */
public List<Object> syncAndReturnAll() { public List<Object> syncAndReturnAll() {
List<Object> formatted = new ArrayList<Object>(); List<Object> formatted = new ArrayList<Object>();
for (Client client : clients) { for (Client client : clients) {
formatted.add(generateResponse(client.getOne()).get()); formatted.add(generateResponse(client.getOne()).get());
} }
return formatted; return formatted;
} }
/** /**
* This method will be removed in Jedis 3.0. Use the methods that return Response's and call * This method will be removed in Jedis 3.0. Use the methods that return
* sync(). * Response's and call sync().
*/ */
@Deprecated @Deprecated
public void execute() { public void execute() {
@@ -71,17 +71,17 @@ public class ShardedJedisPipeline extends PipelineBase {
@Override @Override
protected Client getClient(String key) { protected Client getClient(String key) {
Client client = jedis.getShard(key).getClient(); Client client = jedis.getShard(key).getClient();
clients.add(client); clients.add(client);
results.add(new FutureResult(client)); results.add(new FutureResult(client));
return client; return client;
} }
@Override @Override
protected Client getClient(byte[] key) { protected Client getClient(byte[] key) {
Client client = jedis.getShard(key).getClient(); Client client = jedis.getShard(key).getClient();
clients.add(client); clients.add(client);
results.add(new FutureResult(client)); results.add(new FutureResult(client));
return client; return client;
} }
} }

56
src/main/java/redis/clients/jedis/SortingParams.java
View File

@@ -36,7 +36,7 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams by(final String pattern) { public SortingParams by(final String pattern) {
return by(SafeEncoder.encode(pattern)); return by(SafeEncoder.encode(pattern));
} }
/** /**
@@ -53,9 +53,9 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams by(final byte[] pattern) { public SortingParams by(final byte[] pattern) {
params.add(BY.raw); params.add(BY.raw);
params.add(pattern); params.add(pattern);
return this; return this;
} }
/** /**
@@ -67,13 +67,13 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams nosort() { public SortingParams nosort() {
params.add(BY.raw); params.add(BY.raw);
params.add(NOSORT.raw); params.add(NOSORT.raw);
return this; return this;
} }
public Collection<byte[]> getParams() { public Collection<byte[]> getParams() {
return Collections.unmodifiableCollection(params); return Collections.unmodifiableCollection(params);
} }
/** /**
@@ -82,8 +82,8 @@ public class SortingParams {
* @return the sortingParams Object * @return the sortingParams Object
*/ */
public SortingParams desc() { public SortingParams desc() {
params.add(DESC.raw); params.add(DESC.raw);
return this; return this;
} }
/** /**
@@ -92,8 +92,8 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams asc() { public SortingParams asc() {
params.add(ASC.raw); params.add(ASC.raw);
return this; return this;
} }
/** /**
@@ -105,10 +105,10 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams limit(final int start, final int count) { public SortingParams limit(final int start, final int count) {
params.add(LIMIT.raw); params.add(LIMIT.raw);
params.add(Protocol.toByteArray(start)); params.add(Protocol.toByteArray(start));
params.add(Protocol.toByteArray(count)); params.add(Protocol.toByteArray(count));
return this; return this;
} }
/** /**
@@ -118,8 +118,8 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams alpha() { public SortingParams alpha() {
params.add(ALPHA.raw); params.add(ALPHA.raw);
return this; return this;
} }
/** /**
@@ -138,11 +138,11 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams get(String... patterns) { public SortingParams get(String... patterns) {
for (final String pattern : patterns) { for (final String pattern : patterns) {
params.add(GET.raw); params.add(GET.raw);
params.add(SafeEncoder.encode(pattern)); params.add(SafeEncoder.encode(pattern));
} }
return this; return this;
} }
/** /**
@@ -161,10 +161,10 @@ public class SortingParams {
* @return the SortingParams Object * @return the SortingParams Object
*/ */
public SortingParams get(byte[]... patterns) { public SortingParams get(byte[]... patterns) {
for (final byte[] pattern : patterns) { for (final byte[] pattern : patterns) {
params.add(GET.raw); params.add(GET.raw);
params.add(pattern); params.add(pattern);
} }
return this; return this;
} }
} }

75
src/main/java/redis/clients/jedis/Transaction.java
View File

@@ -6,70 +6,71 @@ import java.util.List;
import redis.clients.jedis.exceptions.JedisDataException; import redis.clients.jedis.exceptions.JedisDataException;
/** /**
* Transaction is nearly identical to Pipeline, only differences are the multi/discard behaviors * Transaction is nearly identical to Pipeline, only differences are the
* multi/discard behaviors
*/ */
public class Transaction extends MultiKeyPipelineBase { public class Transaction extends MultiKeyPipelineBase {
protected boolean inTransaction = true; protected boolean inTransaction = true;
protected Transaction(){ protected Transaction() {
// client will be set later in transaction block // client will be set later in transaction block
} }
public Transaction(final Client client) { public Transaction(final Client client) {
this.client = client; this.client = client;
} }
@Override @Override
protected Client getClient(String key) { protected Client getClient(String key) {
return client; return client;
} }
@Override @Override
protected Client getClient(byte[] key) { protected Client getClient(byte[] key) {
return client; return client;
} }
public List<Object> exec() { public List<Object> exec() {
client.exec(); client.exec();
client.getAll(1); // Discard all but the last reply client.getAll(1); // Discard all but the last reply
List<Object> unformatted = client.getObjectMultiBulkReply(); List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) { if (unformatted == null) {
return null; return null;
} }
List<Object> formatted = new ArrayList<Object>(); List<Object> formatted = new ArrayList<Object>();
for (Object o : unformatted) { for (Object o : unformatted) {
try { try {
formatted.add(generateResponse(o).get()); formatted.add(generateResponse(o).get());
} catch (JedisDataException e) { } catch (JedisDataException e) {
formatted.add(e); formatted.add(e);
} }
} }
return formatted; return formatted;
} }
public List<Response<?>> execGetResponse() { public List<Response<?>> execGetResponse() {
client.exec(); client.exec();
client.getAll(1); // Discard all but the last reply client.getAll(1); // Discard all but the last reply
List<Object> unformatted = client.getObjectMultiBulkReply(); List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) { if (unformatted == null) {
return null; return null;
} }
List<Response<?>> response = new ArrayList<Response<?>>(); List<Response<?>> response = new ArrayList<Response<?>>();
for (Object o : unformatted) { for (Object o : unformatted) {
response.add(generateResponse(o)); response.add(generateResponse(o));
} }
return response; return response;
} }
public String discard() { public String discard() {
client.discard(); client.discard();
client.getAll(1); // Discard all but the last reply client.getAll(1); // Discard all but the last reply
inTransaction = false; inTransaction = false;
clean(); clean();
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
} }

2
src/main/java/redis/clients/jedis/TransactionBlock.java
View File

@@ -13,6 +13,6 @@ public abstract class TransactionBlock extends Transaction {
public abstract void execute() throws JedisException; public abstract void execute() throws JedisException;
public void setClient(Client client) { public void setClient(Client client) {
this.client = client; this.client = client;
} }
} }

86
src/main/java/redis/clients/jedis/Tuple.java
View File

@@ -9,72 +9,72 @@ public class Tuple implements Comparable<Tuple> {
private Double score; private Double score;
public int hashCode() { public int hashCode() {
final int prime = 31; final int prime = 31;
int result = 1; int result = 1;
result = prime * result; result = prime * result;
if (null != element) { if (null != element) {
for (final byte b : element) { for (final byte b : element) {
result = prime * result + b; result = prime * result + b;
} }
} }
long temp; long temp;
temp = Double.doubleToLongBits(score); temp = Double.doubleToLongBits(score);
result = prime * result + (int) (temp ^ (temp >>> 32)); result = prime * result + (int) (temp ^ (temp >>> 32));
return result; return result;
} }
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (this == obj) if (this == obj)
return true; return true;
if (obj == null) if (obj == null)
return false; return false;
if (getClass() != obj.getClass()) if (getClass() != obj.getClass())
return false; return false;
Tuple other = (Tuple) obj; Tuple other = (Tuple) obj;
if (element == null) { if (element == null) {
if (other.element != null) if (other.element != null)
return false; return false;
} else if (!Arrays.equals(element, other.element)) } else if (!Arrays.equals(element, other.element))
return false; return false;
return true; return true;
} }
public int compareTo(Tuple other) { public int compareTo(Tuple other) {
if (Arrays.equals(this.element, other.element)) if (Arrays.equals(this.element, other.element))
return 0; return 0;
else else
return this.score < other.getScore() ? -1 : 1; return this.score < other.getScore() ? -1 : 1;
} }
public Tuple(String element, Double score) { public Tuple(String element, Double score) {
super(); super();
this.element = SafeEncoder.encode(element); this.element = SafeEncoder.encode(element);
this.score = score; this.score = score;
} }
public Tuple(byte[] element, Double score) { public Tuple(byte[] element, Double score) {
super(); super();
this.element = element; this.element = element;
this.score = score; this.score = score;
} }
public String getElement() { public String getElement() {
if (null != element) { if (null != element) {
return SafeEncoder.encode(element); return SafeEncoder.encode(element);
} else { } else {
return null; return null;
} }
} }
public byte[] getBinaryElement() { public byte[] getBinaryElement() {
return element; return element;
} }
public double getScore() { public double getScore() {
return score; return score;
} }
public String toString() { public String toString() {
return '[' + Arrays.toString(element) + ',' + score + ']'; return '[' + Arrays.toString(element) + ',' + score + ']';
} }
} }

28
src/main/java/redis/clients/jedis/ZParams.java
View File

@@ -12,33 +12,33 @@ import redis.clients.util.SafeEncoder;
public class ZParams { public class ZParams {
public enum Aggregate { public enum Aggregate {
SUM, MIN, MAX; SUM, MIN, MAX;
public final byte[] raw; public final byte[] raw;
Aggregate() { Aggregate() {
raw = SafeEncoder.encode(name()); raw = SafeEncoder.encode(name());
} }
} }
private List<byte[]> params = new ArrayList<byte[]>(); private List<byte[]> params = new ArrayList<byte[]>();
public ZParams weights(final int... weights) { public ZParams weights(final int... weights) {
params.add(WEIGHTS.raw); params.add(WEIGHTS.raw);
for (final int weight : weights) { for (final int weight : weights) {
params.add(Protocol.toByteArray(weight)); params.add(Protocol.toByteArray(weight));
} }
return this; return this;
} }
public Collection<byte[]> getParams() { public Collection<byte[]> getParams() {
return Collections.unmodifiableCollection(params); return Collections.unmodifiableCollection(params);
} }
public ZParams aggregate(final Aggregate aggregate) { public ZParams aggregate(final Aggregate aggregate) {
params.add(AGGREGATE.raw); params.add(AGGREGATE.raw);
params.add(aggregate.raw); params.add(aggregate.raw);
return this; return this;
} }
} }

19
src/main/java/redis/clients/jedis/exceptions/JedisAskDataException.java
View File

@@ -4,17 +4,20 @@ import redis.clients.jedis.HostAndPort;
public class JedisAskDataException extends JedisRedirectionException { public class JedisAskDataException extends JedisRedirectionException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisAskDataException(Throwable cause, HostAndPort targetHost, int slot) { public JedisAskDataException(Throwable cause, HostAndPort targetHost,
super(cause, targetHost, slot); int slot) {
super(cause, targetHost, slot);
} }
public JedisAskDataException(String message, Throwable cause, HostAndPort targetHost, int slot) { public JedisAskDataException(String message, Throwable cause,
super(message, cause, targetHost, slot); HostAndPort targetHost, int slot) {
super(message, cause, targetHost, slot);
} }
public JedisAskDataException(String message, HostAndPort targetHost, int slot) { public JedisAskDataException(String message, HostAndPort targetHost,
super(message, targetHost, slot); int slot) {
} super(message, targetHost, slot);
}
} }

13
src/main/java/redis/clients/jedis/exceptions/JedisClusterException.java
View File

@@ -1,18 +1,17 @@
package redis.clients.jedis.exceptions; package redis.clients.jedis.exceptions;
public class JedisClusterException extends JedisDataException { public class JedisClusterException extends JedisDataException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisClusterException(Throwable cause) { public JedisClusterException(Throwable cause) {
super(cause); super(cause);
} }
public JedisClusterException(String message, Throwable cause) { public JedisClusterException(String message, Throwable cause) {
super(message, cause); super(message, cause);
} }
public JedisClusterException(String message) { public JedisClusterException(String message) {
super(message); super(message);
} }
} }

13
src/main/java/redis/clients/jedis/exceptions/JedisClusterMaxRedirectionsException.java
View File

@@ -1,18 +1,17 @@
package redis.clients.jedis.exceptions; package redis.clients.jedis.exceptions;
public class JedisClusterMaxRedirectionsException extends JedisDataException { public class JedisClusterMaxRedirectionsException extends JedisDataException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisClusterMaxRedirectionsException(Throwable cause) { public JedisClusterMaxRedirectionsException(Throwable cause) {
super(cause); super(cause);
} }
public JedisClusterMaxRedirectionsException(String message, Throwable cause) { public JedisClusterMaxRedirectionsException(String message, Throwable cause) {
super(message, cause); super(message, cause);
} }
public JedisClusterMaxRedirectionsException(String message) { public JedisClusterMaxRedirectionsException(String message) {
super(message); super(message);
} }
} }

6
src/main/java/redis/clients/jedis/exceptions/JedisConnectionException.java
View File

@@ -4,14 +4,14 @@ public class JedisConnectionException extends JedisException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisConnectionException(String message) { public JedisConnectionException(String message) {
super(message); super(message);
} }
public JedisConnectionException(Throwable cause) { public JedisConnectionException(Throwable cause) {
super(cause); super(cause);
} }
public JedisConnectionException(String message, Throwable cause) { public JedisConnectionException(String message, Throwable cause) {
super(message, cause); super(message, cause);
} }
} }

6
src/main/java/redis/clients/jedis/exceptions/JedisDataException.java
View File

@@ -4,14 +4,14 @@ public class JedisDataException extends JedisException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisDataException(String message) { public JedisDataException(String message) {
super(message); super(message);
} }
public JedisDataException(Throwable cause) { public JedisDataException(Throwable cause) {
super(cause); super(cause);
} }
public JedisDataException(String message, Throwable cause) { public JedisDataException(String message, Throwable cause) {
super(message, cause); super(message, cause);
} }
} }

7
src/main/java/redis/clients/jedis/exceptions/JedisException.java
View File

@@ -1,18 +1,17 @@
package redis.clients.jedis.exceptions; package redis.clients.jedis.exceptions;
public class JedisException extends RuntimeException { public class JedisException extends RuntimeException {
private static final long serialVersionUID = -2946266495682282677L; private static final long serialVersionUID = -2946266495682282677L;
public JedisException(String message) { public JedisException(String message) {
super(message); super(message);
} }
public JedisException(Throwable e) { public JedisException(Throwable e) {
super(e); super(e);
} }
public JedisException(String message, Throwable cause) { public JedisException(String message, Throwable cause) {
super(message, cause); super(message, cause);
} }
} }

17
src/main/java/redis/clients/jedis/exceptions/JedisMovedDataException.java
View File

@@ -2,20 +2,21 @@ package redis.clients.jedis.exceptions;
import redis.clients.jedis.HostAndPort; import redis.clients.jedis.HostAndPort;
public class JedisMovedDataException extends JedisRedirectionException { public class JedisMovedDataException extends JedisRedirectionException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
public JedisMovedDataException(String message, HostAndPort targetNode, int slot) { public JedisMovedDataException(String message, HostAndPort targetNode,
super(message, targetNode, slot); int slot) {
super(message, targetNode, slot);
} }
public JedisMovedDataException(Throwable cause, HostAndPort targetNode, int slot) { public JedisMovedDataException(Throwable cause, HostAndPort targetNode,
super(cause, targetNode, slot); int slot) {
super(cause, targetNode, slot);
} }
public JedisMovedDataException(String message, Throwable cause, HostAndPort targetNode, int slot) { public JedisMovedDataException(String message, Throwable cause,
super(message, cause, targetNode, slot); HostAndPort targetNode, int slot) {
super(message, cause, targetNode, slot);
} }
} }

42
src/main/java/redis/clients/jedis/exceptions/JedisRedirectionException.java
View File

@@ -2,36 +2,38 @@ package redis.clients.jedis.exceptions;
import redis.clients.jedis.HostAndPort; import redis.clients.jedis.HostAndPort;
public class JedisRedirectionException extends JedisDataException { public class JedisRedirectionException extends JedisDataException {
private static final long serialVersionUID = 3878126572474819403L; private static final long serialVersionUID = 3878126572474819403L;
private HostAndPort targetNode; private HostAndPort targetNode;
private int slot; private int slot;
public JedisRedirectionException(String message, HostAndPort targetNode, int slot) { public JedisRedirectionException(String message, HostAndPort targetNode,
super(message); int slot) {
this.targetNode = targetNode; super(message);
this.slot = slot; this.targetNode = targetNode;
this.slot = slot;
} }
public JedisRedirectionException(Throwable cause, HostAndPort targetNode, int slot) { public JedisRedirectionException(Throwable cause, HostAndPort targetNode,
super(cause); int slot) {
this.targetNode = targetNode; super(cause);
this.slot = slot; this.targetNode = targetNode;
this.slot = slot;
} }
public JedisRedirectionException(String message, Throwable cause, HostAndPort targetNode, int slot) { public JedisRedirectionException(String message, Throwable cause,
super(message, cause); HostAndPort targetNode, int slot) {
this.targetNode = targetNode; super(message, cause);
this.slot = slot; this.targetNode = targetNode;
this.slot = slot;
} }
public HostAndPort getTargetNode() { public HostAndPort getTargetNode() {
return targetNode; return targetNode;
} }
public int getSlot() { public int getSlot() {
return slot; return slot;
} }
} }

40
src/main/java/redis/clients/util/Hashing.java
View File

@@ -8,28 +8,28 @@ public interface Hashing {
public ThreadLocal<MessageDigest> md5Holder = new ThreadLocal<MessageDigest>(); public ThreadLocal<MessageDigest> md5Holder = new ThreadLocal<MessageDigest>();
public static final Hashing MD5 = new Hashing() { public static final Hashing MD5 = new Hashing() {
public long hash(String key) { public long hash(String key) {
return hash(SafeEncoder.encode(key)); return hash(SafeEncoder.encode(key));
} }
public long hash(byte[] key) { public long hash(byte[] key) {
try { try {
if (md5Holder.get() == null) { if (md5Holder.get() == null) {
md5Holder.set(MessageDigest.getInstance("MD5")); md5Holder.set(MessageDigest.getInstance("MD5"));
} }
} catch (NoSuchAlgorithmException e) { } catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("++++ no md5 algorythm found"); throw new IllegalStateException("++++ no md5 algorythm found");
} }
MessageDigest md5 = md5Holder.get(); MessageDigest md5 = md5Holder.get();
md5.reset(); md5.reset();
md5.update(key); md5.update(key);
byte[] bKey = md5.digest(); byte[] bKey = md5.digest();
long res = ((long) (bKey[3] & 0xFF) << 24) long res = ((long) (bKey[3] & 0xFF) << 24)
| ((long) (bKey[2] & 0xFF) << 16) | ((long) (bKey[2] & 0xFF) << 16)
| ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF); | ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);
return res; return res;
} }
}; };
public long hash(String key); public long hash(String key);

140
src/main/java/redis/clients/util/JedisByteHashMap.java
View File

@@ -10,127 +10,127 @@ import java.util.Map;
import java.util.Set; import java.util.Set;
public class JedisByteHashMap implements Map<byte[], byte[]>, Cloneable, public class JedisByteHashMap implements Map<byte[], byte[]>, Cloneable,
Serializable { Serializable {
private static final long serialVersionUID = -6971431362627219416L; private static final long serialVersionUID = -6971431362627219416L;
private Map<ByteArrayWrapper, byte[]> internalMap = new HashMap<ByteArrayWrapper, byte[]>(); private Map<ByteArrayWrapper, byte[]> internalMap = new HashMap<ByteArrayWrapper, byte[]>();
public void clear() { public void clear() {
internalMap.clear(); internalMap.clear();
} }
public boolean containsKey(Object key) { public boolean containsKey(Object key) {
if (key instanceof byte[]) if (key instanceof byte[])
return internalMap.containsKey(new ByteArrayWrapper((byte[]) key)); return internalMap.containsKey(new ByteArrayWrapper((byte[]) key));
return internalMap.containsKey(key); return internalMap.containsKey(key);
} }
public boolean containsValue(Object value) { public boolean containsValue(Object value) {
return internalMap.containsValue(value); return internalMap.containsValue(value);
} }
public Set<java.util.Map.Entry<byte[], byte[]>> entrySet() { public Set<java.util.Map.Entry<byte[], byte[]>> entrySet() {
Iterator<java.util.Map.Entry<ByteArrayWrapper, byte[]>> iterator = internalMap Iterator<java.util.Map.Entry<ByteArrayWrapper, byte[]>> iterator = internalMap
.entrySet().iterator(); .entrySet().iterator();
HashSet<Entry<byte[], byte[]>> hashSet = new HashSet<java.util.Map.Entry<byte[], byte[]>>(); HashSet<Entry<byte[], byte[]>> hashSet = new HashSet<java.util.Map.Entry<byte[], byte[]>>();
while (iterator.hasNext()) { while (iterator.hasNext()) {
Entry<ByteArrayWrapper, byte[]> entry = iterator.next(); Entry<ByteArrayWrapper, byte[]> entry = iterator.next();
hashSet.add(new JedisByteEntry(entry.getKey().data, entry hashSet.add(new JedisByteEntry(entry.getKey().data, entry
.getValue())); .getValue()));
} }
return hashSet; return hashSet;
} }
public byte[] get(Object key) { public byte[] get(Object key) {
if (key instanceof byte[]) if (key instanceof byte[])
return internalMap.get(new ByteArrayWrapper((byte[]) key)); return internalMap.get(new ByteArrayWrapper((byte[]) key));
return internalMap.get(key); return internalMap.get(key);
} }
public boolean isEmpty() { public boolean isEmpty() {
return internalMap.isEmpty(); return internalMap.isEmpty();
} }
public Set<byte[]> keySet() { public Set<byte[]> keySet() {
Set<byte[]> keySet = new HashSet<byte[]>(); Set<byte[]> keySet = new HashSet<byte[]>();
Iterator<ByteArrayWrapper> iterator = internalMap.keySet().iterator(); Iterator<ByteArrayWrapper> iterator = internalMap.keySet().iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
keySet.add(iterator.next().data); keySet.add(iterator.next().data);
} }
return keySet; return keySet;
} }
public byte[] put(byte[] key, byte[] value) { public byte[] put(byte[] key, byte[] value) {
return internalMap.put(new ByteArrayWrapper(key), value); return internalMap.put(new ByteArrayWrapper(key), value);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public void putAll(Map<? extends byte[], ? extends byte[]> m) { public void putAll(Map<? extends byte[], ? extends byte[]> m) {
Iterator<?> iterator = m.entrySet().iterator(); Iterator<?> iterator = m.entrySet().iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
Entry<? extends byte[], ? extends byte[]> next = (Entry<? extends byte[], ? extends byte[]>) iterator Entry<? extends byte[], ? extends byte[]> next = (Entry<? extends byte[], ? extends byte[]>) iterator
.next(); .next();
internalMap.put(new ByteArrayWrapper(next.getKey()), next internalMap.put(new ByteArrayWrapper(next.getKey()),
.getValue()); next.getValue());
} }
} }
public byte[] remove(Object key) { public byte[] remove(Object key) {
if (key instanceof byte[]) if (key instanceof byte[])
return internalMap.remove(new ByteArrayWrapper((byte[]) key)); return internalMap.remove(new ByteArrayWrapper((byte[]) key));
return internalMap.remove(key); return internalMap.remove(key);
} }
public int size() { public int size() {
return internalMap.size(); return internalMap.size();
} }
public Collection<byte[]> values() { public Collection<byte[]> values() {
return internalMap.values(); return internalMap.values();
} }
private static final class ByteArrayWrapper { private static final class ByteArrayWrapper {
private final byte[] data; private final byte[] data;
public ByteArrayWrapper(byte[] data) { public ByteArrayWrapper(byte[] data) {
if (data == null) { if (data == null) {
throw new NullPointerException(); throw new NullPointerException();
} }
this.data = data; this.data = data;
} }
public boolean equals(Object other) { public boolean equals(Object other) {
if (!(other instanceof ByteArrayWrapper)) { if (!(other instanceof ByteArrayWrapper)) {
return false; return false;
} }
return Arrays.equals(data, ((ByteArrayWrapper) other).data); return Arrays.equals(data, ((ByteArrayWrapper) other).data);
} }
public int hashCode() { public int hashCode() {
return Arrays.hashCode(data); return Arrays.hashCode(data);
} }
} }
private static final class JedisByteEntry implements Entry<byte[], byte[]> { private static final class JedisByteEntry implements Entry<byte[], byte[]> {
private byte[] value; private byte[] value;
private byte[] key; private byte[] key;
public JedisByteEntry(byte[] key, byte[] value) { public JedisByteEntry(byte[] key, byte[] value) {
this.key = key; this.key = key;
this.value = value; this.value = value;
} }
public byte[] getKey() { public byte[] getKey() {
return this.key; return this.key;
} }
public byte[] getValue() { public byte[] getValue() {
return this.value; return this.value;
} }
public byte[] setValue(byte[] value) { public byte[] setValue(byte[] value) {
this.value = value; this.value = value;
return value; return value;
} }
} }
} }

34
src/main/java/redis/clients/util/JedisClusterCRC16.java
View File

@@ -1,21 +1,23 @@
package redis.clients.util; package redis.clients.util;
public class JedisClusterCRC16 { public class JedisClusterCRC16 {
public final static int polynomial = 0x1021; // Represents x^16+x^12+x^5+1 public final static int polynomial = 0x1021; // Represents x^16+x^12+x^5+1
static int crc; static int crc;
public static int getSlot(String key) {
crc = 0x0000;
for (byte b : key.getBytes()) {
for (int i = 0; i < 8; i++) {
boolean bit = ((b >> (7-i) & 1) == 1);
boolean c15 = ((crc >> 15 & 1) == 1);
crc <<= 1;
// If coefficient of bit and remainder polynomial = 1 xor crc with polynomial
if (c15 ^ bit) crc ^= polynomial;
}
}
return crc &= 0xffff % 16384; public static int getSlot(String key) {
} crc = 0x0000;
for (byte b : key.getBytes()) {
for (int i = 0; i < 8; i++) {
boolean bit = ((b >> (7 - i) & 1) == 1);
boolean c15 = ((crc >> 15 & 1) == 1);
crc <<= 1;
// If coefficient of bit and remainder polynomial = 1 xor crc
// with polynomial
if (c15 ^ bit)
crc ^= polynomial;
}
}
return crc &= 0xffff % 16384;
}
} }

126
src/main/java/redis/clients/util/MurmurHash.java
View File

@@ -40,7 +40,7 @@ public class MurmurHash implements Hashing {
* @return The 32 bit hash of the bytes in question. * @return The 32 bit hash of the bytes in question.
*/ */
public static int hash(byte[] data, int seed) { public static int hash(byte[] data, int seed) {
return hash(ByteBuffer.wrap(data), seed); return hash(ByteBuffer.wrap(data), seed);
} }
/** /**
@@ -57,7 +57,7 @@ public class MurmurHash implements Hashing {
* @return The 32-bit hash of the data in question. * @return The 32-bit hash of the data in question.
*/ */
public static int hash(byte[] data, int offset, int length, int seed) { public static int hash(byte[] data, int offset, int length, int seed) {
return hash(ByteBuffer.wrap(data, offset, length), seed); return hash(ByteBuffer.wrap(data, offset, length), seed);
} }
/** /**
@@ -70,97 +70,97 @@ public class MurmurHash implements Hashing {
* @return The 32 bit murmur hash of the bytes in the buffer. * @return The 32 bit murmur hash of the bytes in the buffer.
*/ */
public static int hash(ByteBuffer buf, int seed) { public static int hash(ByteBuffer buf, int seed) {
// save byte order for later restoration // save byte order for later restoration
ByteOrder byteOrder = buf.order(); ByteOrder byteOrder = buf.order();
buf.order(ByteOrder.LITTLE_ENDIAN); buf.order(ByteOrder.LITTLE_ENDIAN);
int m = 0x5bd1e995; int m = 0x5bd1e995;
int r = 24; int r = 24;
int h = seed ^ buf.remaining(); int h = seed ^ buf.remaining();
int k; int k;
while (buf.remaining() >= 4) { while (buf.remaining() >= 4) {
k = buf.getInt(); k = buf.getInt();
k *= m; k *= m;
k ^= k >>> r; k ^= k >>> r;
k *= m; k *= m;
h *= m; h *= m;
h ^= k; h ^= k;
} }
if (buf.remaining() > 0) { if (buf.remaining() > 0) {
ByteBuffer finish = ByteBuffer.allocate(4).order( ByteBuffer finish = ByteBuffer.allocate(4).order(
ByteOrder.LITTLE_ENDIAN); ByteOrder.LITTLE_ENDIAN);
// for big-endian version, use this first: // for big-endian version, use this first:
// finish.position(4-buf.remaining()); // finish.position(4-buf.remaining());
finish.put(buf).rewind(); finish.put(buf).rewind();
h ^= finish.getInt(); h ^= finish.getInt();
h *= m; h *= m;
} }
h ^= h >>> 13; h ^= h >>> 13;
h *= m; h *= m;
h ^= h >>> 15; h ^= h >>> 15;
buf.order(byteOrder); buf.order(byteOrder);
return h; return h;
} }
public static long hash64A(byte[] data, int seed) { public static long hash64A(byte[] data, int seed) {
return hash64A(ByteBuffer.wrap(data), seed); return hash64A(ByteBuffer.wrap(data), seed);
} }
public static long hash64A(byte[] data, int offset, int length, int seed) { public static long hash64A(byte[] data, int offset, int length, int seed) {
return hash64A(ByteBuffer.wrap(data, offset, length), seed); return hash64A(ByteBuffer.wrap(data, offset, length), seed);
} }
public static long hash64A(ByteBuffer buf, int seed) { public static long hash64A(ByteBuffer buf, int seed) {
ByteOrder byteOrder = buf.order(); ByteOrder byteOrder = buf.order();
buf.order(ByteOrder.LITTLE_ENDIAN); buf.order(ByteOrder.LITTLE_ENDIAN);
long m = 0xc6a4a7935bd1e995L; long m = 0xc6a4a7935bd1e995L;
int r = 47; int r = 47;
long h = seed ^ (buf.remaining() * m); long h = seed ^ (buf.remaining() * m);
long k; long k;
while (buf.remaining() >= 8) { while (buf.remaining() >= 8) {
k = buf.getLong(); k = buf.getLong();
k *= m; k *= m;
k ^= k >>> r; k ^= k >>> r;
k *= m; k *= m;
h ^= k; h ^= k;
h *= m; h *= m;
} }
if (buf.remaining() > 0) { if (buf.remaining() > 0) {
ByteBuffer finish = ByteBuffer.allocate(8).order( ByteBuffer finish = ByteBuffer.allocate(8).order(
ByteOrder.LITTLE_ENDIAN); ByteOrder.LITTLE_ENDIAN);
// for big-endian version, do this first: // for big-endian version, do this first:
// finish.position(8-buf.remaining()); // finish.position(8-buf.remaining());
finish.put(buf).rewind(); finish.put(buf).rewind();
h ^= finish.getLong(); h ^= finish.getLong();
h *= m; h *= m;
} }
h ^= h >>> r; h ^= h >>> r;
h *= m; h *= m;
h ^= h >>> r; h ^= h >>> r;
buf.order(byteOrder); buf.order(byteOrder);
return h; return h;
} }
public long hash(byte[] key) { public long hash(byte[] key) {
return hash64A(key, 0x1234ABCD); return hash64A(key, 0x1234ABCD);
} }
public long hash(String key) { public long hash(String key) {
return hash(SafeEncoder.encode(key)); return hash(SafeEncoder.encode(key));
} }
} }

118
src/main/java/redis/clients/util/RedisInputStream.java
View File

@@ -29,84 +29,84 @@ public class RedisInputStream extends FilterInputStream {
protected int count, limit; protected int count, limit;
public RedisInputStream(InputStream in, int size) { public RedisInputStream(InputStream in, int size) {
super(in); super(in);
if (size <= 0) { if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0"); throw new IllegalArgumentException("Buffer size <= 0");
} }
buf = new byte[size]; buf = new byte[size];
} }
public RedisInputStream(InputStream in) { public RedisInputStream(InputStream in) {
this(in, 8192); this(in, 8192);
} }
public byte readByte() throws IOException { public byte readByte() throws IOException {
if (count == limit) { if (count == limit) {
fill(); fill();
} }
return buf[count++]; return buf[count++];
} }
public String readLine() { public String readLine() {
int b; int b;
byte c; byte c;
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
try { try {
while (true) { while (true) {
if (count == limit) { if (count == limit) {
fill(); fill();
} }
if (limit == -1) if (limit == -1)
break; break;
b = buf[count++]; b = buf[count++];
if (b == '\r') { if (b == '\r') {
if (count == limit) { if (count == limit) {
fill(); fill();
} }
if (limit == -1) { if (limit == -1) {
sb.append((char) b); sb.append((char) b);
break; break;
} }
c = buf[count++]; c = buf[count++];
if (c == '\n') { if (c == '\n') {
break; break;
} }
sb.append((char) b); sb.append((char) b);
sb.append((char) c); sb.append((char) c);
} else { } else {
sb.append((char) b); sb.append((char) b);
} }
} }
} catch (IOException e) { } catch (IOException e) {
throw new JedisConnectionException(e); throw new JedisConnectionException(e);
} }
String reply = sb.toString(); String reply = sb.toString();
if (reply.length() == 0) { if (reply.length() == 0) {
throw new JedisConnectionException( throw new JedisConnectionException(
"It seems like server has closed the connection."); "It seems like server has closed the connection.");
} }
return reply; return reply;
} }
public int read(byte[] b, int off, int len) throws IOException { public int read(byte[] b, int off, int len) throws IOException {
if (count == limit) { if (count == limit) {
fill(); fill();
if (limit == -1) if (limit == -1)
return -1; return -1;
} }
final int length = Math.min(limit - count, len); final int length = Math.min(limit - count, len);
System.arraycopy(buf, count, b, off, length); System.arraycopy(buf, count, b, off, length);
count += length; count += length;
return length; return length;
} }
private void fill() throws IOException { private void fill() throws IOException {
limit = in.read(buf); limit = in.read(buf);
count = 0; count = 0;
} }
} }

330
src/main/java/redis/clients/util/RedisOutputStream.java
View File

@@ -1,11 +1,13 @@
package redis.clients.util; package redis.clients.util;
import java.io.*; import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/** /**
* The class implements a buffered output stream without synchronization * The class implements a buffered output stream without synchronization There
* There are also special operations like in-place string encoding. * are also special operations like in-place string encoding. This stream fully
* This stream fully ignore mark/reset and should not be used outside Jedis * ignore mark/reset and should not be used outside Jedis
*/ */
public final class RedisOutputStream extends FilterOutputStream { public final class RedisOutputStream extends FilterOutputStream {
protected final byte buf[]; protected final byte buf[];
@@ -13,218 +15,212 @@ public final class RedisOutputStream extends FilterOutputStream {
protected int count; protected int count;
public RedisOutputStream(final OutputStream out) { public RedisOutputStream(final OutputStream out) {
this(out, 8192); this(out, 8192);
} }
public RedisOutputStream(final OutputStream out, final int size) { public RedisOutputStream(final OutputStream out, final int size) {
super(out); super(out);
if (size <= 0) { if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0"); throw new IllegalArgumentException("Buffer size <= 0");
} }
buf = new byte[size]; buf = new byte[size];
} }
private void flushBuffer() throws IOException { private void flushBuffer() throws IOException {
if (count > 0) { if (count > 0) {
out.write(buf, 0, count); out.write(buf, 0, count);
count = 0; count = 0;
} }
} }
public void write(final byte b) throws IOException { public void write(final byte b) throws IOException {
buf[count++] = b; buf[count++] = b;
if (count == buf.length) { if (count == buf.length) {
flushBuffer(); flushBuffer();
} }
} }
public void write(final byte[] b) throws IOException { public void write(final byte[] b) throws IOException {
write(b, 0, b.length); write(b, 0, b.length);
} }
public void write(final byte b[], final int off, final int len) throws IOException { public void write(final byte b[], final int off, final int len)
if (len >= buf.length) { throws IOException {
flushBuffer(); if (len >= buf.length) {
out.write(b, off, len); flushBuffer();
} else { out.write(b, off, len);
if (len >= buf.length - count) { } else {
flushBuffer(); if (len >= buf.length - count) {
} flushBuffer();
}
System.arraycopy(b, off, buf, count, len); System.arraycopy(b, off, buf, count, len);
count += len; count += len;
} }
} }
public void writeAsciiCrLf(final String in) throws IOException { public void writeAsciiCrLf(final String in) throws IOException {
final int size = in.length(); final int size = in.length();
for (int i = 0; i != size; ++i) { for (int i = 0; i != size; ++i) {
buf[count++] = (byte) in.charAt(i); buf[count++] = (byte) in.charAt(i);
if (count == buf.length) { if (count == buf.length) {
flushBuffer(); flushBuffer();
} }
} }
writeCrLf(); writeCrLf();
} }
public static boolean isSurrogate(final char ch) { public static boolean isSurrogate(final char ch) {
return ch >= Character.MIN_SURROGATE && ch <= Character.MAX_SURROGATE; return ch >= Character.MIN_SURROGATE && ch <= Character.MAX_SURROGATE;
} }
public static int utf8Length (final String str) { public static int utf8Length(final String str) {
int strLen = str.length(), utfLen = 0; int strLen = str.length(), utfLen = 0;
for(int i = 0; i != strLen; ++i) { for (int i = 0; i != strLen; ++i) {
char c = str.charAt(i); char c = str.charAt(i);
if (c < 0x80) { if (c < 0x80) {
utfLen++; utfLen++;
} else if (c < 0x800) { } else if (c < 0x800) {
utfLen += 2; utfLen += 2;
} else if (isSurrogate(c)) { } else if (isSurrogate(c)) {
i++; i++;
utfLen += 4; utfLen += 4;
} else { } else {
utfLen += 3; utfLen += 3;
} }
} }
return utfLen; return utfLen;
} }
public void writeCrLf() throws IOException { public void writeCrLf() throws IOException {
if (2 >= buf.length - count) { if (2 >= buf.length - count) {
flushBuffer(); flushBuffer();
} }
buf[count++] = '\r'; buf[count++] = '\r';
buf[count++] = '\n'; buf[count++] = '\n';
} }
public void writeUtf8CrLf(final String str) throws IOException { public void writeUtf8CrLf(final String str) throws IOException {
int strLen = str.length(); int strLen = str.length();
int i; int i;
for (i = 0; i < strLen; i++) { for (i = 0; i < strLen; i++) {
char c = str.charAt(i); char c = str.charAt(i);
if (!(c < 0x80)) break; if (!(c < 0x80))
buf[count++] = (byte) c; break;
if(count == buf.length) { buf[count++] = (byte) c;
flushBuffer(); if (count == buf.length) {
} flushBuffer();
} }
}
for (; i < strLen; i++) { for (; i < strLen; i++) {
char c = str.charAt(i); char c = str.charAt(i);
if (c < 0x80) { if (c < 0x80) {
buf[count++] = (byte) c; buf[count++] = (byte) c;
if(count == buf.length) { if (count == buf.length) {
flushBuffer(); flushBuffer();
} }
} else if (c < 0x800) { } else if (c < 0x800) {
if(2 >= buf.length - count) { if (2 >= buf.length - count) {
flushBuffer(); flushBuffer();
} }
buf[count++] = (byte)(0xc0 | (c >> 6)); buf[count++] = (byte) (0xc0 | (c >> 6));
buf[count++] = (byte)(0x80 | (c & 0x3f)); buf[count++] = (byte) (0x80 | (c & 0x3f));
} else if (isSurrogate(c)) { } else if (isSurrogate(c)) {
if(4 >= buf.length - count) { if (4 >= buf.length - count) {
flushBuffer(); flushBuffer();
} }
int uc = Character.toCodePoint(c, str.charAt(i++)); int uc = Character.toCodePoint(c, str.charAt(i++));
buf[count++] = ((byte)(0xf0 | ((uc >> 18)))); buf[count++] = ((byte) (0xf0 | ((uc >> 18))));
buf[count++] = ((byte)(0x80 | ((uc >> 12) & 0x3f))); buf[count++] = ((byte) (0x80 | ((uc >> 12) & 0x3f)));
buf[count++] = ((byte)(0x80 | ((uc >> 6) & 0x3f))); buf[count++] = ((byte) (0x80 | ((uc >> 6) & 0x3f)));
buf[count++] = ((byte)(0x80 | (uc & 0x3f))); buf[count++] = ((byte) (0x80 | (uc & 0x3f)));
} else { } else {
if(3 >= buf.length - count) { if (3 >= buf.length - count) {
flushBuffer(); flushBuffer();
} }
buf[count++] =((byte)(0xe0 | ((c >> 12)))); buf[count++] = ((byte) (0xe0 | ((c >> 12))));
buf[count++] =((byte)(0x80 | ((c >> 6) & 0x3f))); buf[count++] = ((byte) (0x80 | ((c >> 6) & 0x3f)));
buf[count++] =((byte)(0x80 | (c & 0x3f))); buf[count++] = ((byte) (0x80 | (c & 0x3f)));
} }
} }
writeCrLf(); writeCrLf();
} }
private final static int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE}; private final static int[] sizeTable = { 9, 99, 999, 9999, 99999, 999999,
9999999, 99999999, 999999999, Integer.MAX_VALUE };
private final static byte[] DigitTens = { private final static byte[] DigitTens = { '0', '0', '0', '0', '0', '0',
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4', '5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '8', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '9', '9',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '9', '9', '9', };
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
};
private final static byte[] DigitOnes = { private final static byte[] DigitOnes = { '0', '1', '2', '3', '4', '5',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '7', '8', '9', };
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
};
private final static byte[] digits = { private final static byte[] digits = { '0', '1', '2', '3', '4', '5', '6',
'0', '1', '2', '3', '4', '5', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'6', '7', '8', '9', 'a', 'b', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'c', 'd', 'e', 'f', 'g', 'h', 'x', 'y', 'z' };
'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
public void writeIntCrLf(int value) throws IOException { public void writeIntCrLf(int value) throws IOException {
if (value < 0) { if (value < 0) {
write('-'); write((byte) '-');
value = -value; value = -value;
} }
int size = 0; int size = 0;
while (value > sizeTable[size]) while (value > sizeTable[size])
size++; size++;
size++; size++;
if (size >= buf.length - count) { if (size >= buf.length - count) {
flushBuffer(); flushBuffer();
} }
int q, r; int q, r;
int charPos = count + size; int charPos = count + size;
while (value >= 65536) { while (value >= 65536) {
q = value / 100; q = value / 100;
r = value - ((q << 6) + (q << 5) + (q << 2)); r = value - ((q << 6) + (q << 5) + (q << 2));
value = q; value = q;
buf[--charPos] = DigitOnes[r]; buf[--charPos] = DigitOnes[r];
buf[--charPos] = DigitTens[r]; buf[--charPos] = DigitTens[r];
} }
for (; ;) { for (;;) {
q = (value * 52429) >>> (16 + 3); q = (value * 52429) >>> (16 + 3);
r = value - ((q << 3) + (q << 1)); r = value - ((q << 3) + (q << 1));
buf[--charPos] = digits[r]; buf[--charPos] = digits[r];
value = q; value = q;
if (value == 0) break; if (value == 0)
} break;
count += size; }
count += size;
writeCrLf(); writeCrLf();
} }
public void flush() throws IOException { public void flush() throws IOException {
flushBuffer(); flushBuffer();
out.flush(); out.flush();
} }
} }

42
src/main/java/redis/clients/util/SafeEncoder.java
View File

@@ -11,31 +11,31 @@ import redis.clients.jedis.exceptions.JedisException;
* *
*/ */
public class SafeEncoder { public class SafeEncoder {
public static byte[][] encodeMany(final String... strs){ public static byte[][] encodeMany(final String... strs) {
byte[][] many = new byte[strs.length][]; byte[][] many = new byte[strs.length][];
for(int i=0;i<strs.length;i++){ for (int i = 0; i < strs.length; i++) {
many[i] = encode(strs[i]); many[i] = encode(strs[i]);
}
return many;
} }
return many;
}
public static byte[] encode(final String str) { public static byte[] encode(final String str) {
try { try {
if (str == null) { if (str == null) {
throw new JedisDataException( throw new JedisDataException(
"value sent to redis cannot be null"); "value sent to redis cannot be null");
} }
return str.getBytes(Protocol.CHARSET); return str.getBytes(Protocol.CHARSET);
} catch (UnsupportedEncodingException e) { } catch (UnsupportedEncodingException e) {
throw new JedisException(e); throw new JedisException(e);
} }
} }
public static String encode(final byte[] data) { public static String encode(final byte[] data) {
try { try {
return new String(data, Protocol.CHARSET); return new String(data, Protocol.CHARSET);
} catch (UnsupportedEncodingException e) { } catch (UnsupportedEncodingException e) {
throw new JedisException(e); throw new JedisException(e);
} }
} }
} }

6
src/main/java/redis/clients/util/ShardInfo.java
View File

@@ -7,14 +7,14 @@ public abstract class ShardInfo<T> {
} }
public ShardInfo(int weight) { public ShardInfo(int weight) {
this.weight = weight; this.weight = weight;
} }
public int getWeight() { public int getWeight() {
return this.weight; return this.weight;
} }
protected abstract T createResource(); protected abstract T createResource();
public abstract String getName(); public abstract String getName();
} }

86
src/main/java/redis/clients/util/Sharded.java
View File

@@ -26,91 +26,93 @@ public class Sharded<R, S extends ShardInfo<R>> {
private Pattern tagPattern = null; private Pattern tagPattern = null;
// the tag is anything between {} // the tag is anything between {}
public static final Pattern DEFAULT_KEY_TAG_PATTERN = Pattern public static final Pattern DEFAULT_KEY_TAG_PATTERN = Pattern
.compile("\\{(.+?)\\}"); .compile("\\{(.+?)\\}");
public Sharded(List<S> shards) { public Sharded(List<S> shards) {
this(shards, Hashing.MURMUR_HASH); // MD5 is really not good as we works this(shards, Hashing.MURMUR_HASH); // MD5 is really not good as we works
// with 64-bits not 128 // with 64-bits not 128
} }
public Sharded(List<S> shards, Hashing algo) { public Sharded(List<S> shards, Hashing algo) {
this.algo = algo; this.algo = algo;
initialize(shards); initialize(shards);
} }
public Sharded(List<S> shards, Pattern tagPattern) { public Sharded(List<S> shards, Pattern tagPattern) {
this(shards, Hashing.MURMUR_HASH, tagPattern); // MD5 is really not good this(shards, Hashing.MURMUR_HASH, tagPattern); // MD5 is really not good
// as we works with // as we works with
// 64-bits not 128 // 64-bits not 128
} }
public Sharded(List<S> shards, Hashing algo, Pattern tagPattern) { public Sharded(List<S> shards, Hashing algo, Pattern tagPattern) {
this.algo = algo; this.algo = algo;
this.tagPattern = tagPattern; this.tagPattern = tagPattern;
initialize(shards); initialize(shards);
} }
private void initialize(List<S> shards) { private void initialize(List<S> shards) {
nodes = new TreeMap<Long, S>(); nodes = new TreeMap<Long, S>();
for (int i = 0; i != shards.size(); ++i) { for (int i = 0; i != shards.size(); ++i) {
final S shardInfo = shards.get(i); final S shardInfo = shards.get(i);
if (shardInfo.getName() == null) if (shardInfo.getName() == null)
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) { for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
nodes.put(this.algo.hash("SHARD-" + i + "-NODE-" + n), shardInfo); nodes.put(this.algo.hash("SHARD-" + i + "-NODE-" + n),
} shardInfo);
else }
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) { else
nodes.put(this.algo.hash(shardInfo.getName() + "*" + shardInfo.getWeight() + n), shardInfo); for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
} nodes.put(
resources.put(shardInfo, shardInfo.createResource()); this.algo.hash(shardInfo.getName() + "*"
} + shardInfo.getWeight() + n), shardInfo);
}
resources.put(shardInfo, shardInfo.createResource());
}
} }
public R getShard(byte[] key) { public R getShard(byte[] key) {
return resources.get(getShardInfo(key)); return resources.get(getShardInfo(key));
} }
public R getShard(String key) { public R getShard(String key) {
return resources.get(getShardInfo(key)); return resources.get(getShardInfo(key));
} }
public S getShardInfo(byte[] key) { public S getShardInfo(byte[] key) {
SortedMap<Long, S> tail = nodes.tailMap(algo.hash(key)); SortedMap<Long, S> tail = nodes.tailMap(algo.hash(key));
if (tail.isEmpty()) { if (tail.isEmpty()) {
return nodes.get(nodes.firstKey()); return nodes.get(nodes.firstKey());
} }
return tail.get(tail.firstKey()); return tail.get(tail.firstKey());
} }
public S getShardInfo(String key) { public S getShardInfo(String key) {
return getShardInfo(SafeEncoder.encode(getKeyTag(key))); return getShardInfo(SafeEncoder.encode(getKeyTag(key)));
} }
/** /**
* A key tag is a special pattern inside a key that, if preset, is the only * A key tag is a special pattern inside a key that, if preset, is the only
* part of the key hashed in order to select the server for this key. * part of the key hashed in order to select the server for this key.
* *
* @see http://code.google.com/p/redis/wiki/FAQ#I * @see http://code.google.com/p/redis/wiki/FAQ#I
* 'm_using_some_form_of_key_hashing_for_partitioning,_but_wh * 'm_using_some_form_of_key_hashing_for_partitioning,_but_wh
* @param key * @param key
* @return The tag if it exists, or the original key * @return The tag if it exists, or the original key
*/ */
public String getKeyTag(String key) { public String getKeyTag(String key) {
if (tagPattern != null) { if (tagPattern != null) {
Matcher m = tagPattern.matcher(key); Matcher m = tagPattern.matcher(key);
if (m.find()) if (m.find())
return m.group(1); return m.group(1);
} }
return key; return key;
} }
public Collection<S> getAllShardInfo() { public Collection<S> getAllShardInfo() {
return Collections.unmodifiableCollection(nodes.values()); return Collections.unmodifiableCollection(nodes.values());
} }
public Collection<R> getAllShards() { public Collection<R> getAllShards() {
return Collections.unmodifiableCollection(resources.values()); return Collections.unmodifiableCollection(resources.values());
} }
} }

80
src/main/java/redis/clients/util/Slowlog.java
View File

@@ -4,50 +4,50 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
public class Slowlog { public class Slowlog {
private final long id; private final long id;
private final long timeStamp; private final long timeStamp;
private final long executionTime; private final long executionTime;
private final List<String> args; private final List<String> args;
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static List<Slowlog> from(List<Object> nestedMultiBulkReply){ public static List<Slowlog> from(List<Object> nestedMultiBulkReply) {
List<Slowlog> logs = new ArrayList<Slowlog>(nestedMultiBulkReply.size()); List<Slowlog> logs = new ArrayList<Slowlog>(nestedMultiBulkReply.size());
for(Object obj : nestedMultiBulkReply){ for (Object obj : nestedMultiBulkReply) {
List<Object> properties = (List<Object>)obj; List<Object> properties = (List<Object>) obj;
logs.add(new Slowlog(properties)); logs.add(new Slowlog(properties));
}
return logs;
}
@SuppressWarnings("unchecked")
private Slowlog(List<Object> properties) {
super();
this.id = (Long)properties.get(0);
this.timeStamp = (Long)properties.get(1);
this.executionTime = (Long)properties.get(2);
List<byte[]> bargs = (List<byte[]>)properties.get(3);
this.args = new ArrayList<String>(bargs.size());
for(byte[] barg:bargs){
this.args.add(SafeEncoder.encode(barg));
}
} }
public long getId() { return logs;
return id; }
}
public long getTimeStamp() { @SuppressWarnings("unchecked")
return timeStamp; private Slowlog(List<Object> properties) {
} super();
this.id = (Long) properties.get(0);
this.timeStamp = (Long) properties.get(1);
this.executionTime = (Long) properties.get(2);
public long getExecutionTime() { List<byte[]> bargs = (List<byte[]>) properties.get(3);
return executionTime; this.args = new ArrayList<String>(bargs.size());
}
public List<String> getArgs() { for (byte[] barg : bargs) {
return args; this.args.add(SafeEncoder.encode(barg));
} }
}
public long getId() {
return id;
}
public long getTimeStamp() {
return timeStamp;
}
public long getExecutionTime() {
return executionTime;
}
public List<String> getArgs() {
return args;
}
} }

4
src/test/java/redis/clients/jedis/tests/BuilderFactoryTest.java
View File

@@ -8,7 +8,7 @@ import redis.clients.jedis.BuilderFactory;
public class BuilderFactoryTest extends Assert { public class BuilderFactoryTest extends Assert {
@Test @Test
public void buildDouble() { public void buildDouble() {
Double build = BuilderFactory.DOUBLE.build("1.0".getBytes()); Double build = BuilderFactory.DOUBLE.build("1.0".getBytes());
assertEquals(new Double(1.0), build); assertEquals(new Double(1.0), build);
} }
} }

18
src/test/java/redis/clients/jedis/tests/ConnectionTest.java
View File

@@ -13,31 +13,31 @@ public class ConnectionTest extends Assert {
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
client = new Connection(); client = new Connection();
} }
@After @After
public void tearDown() throws Exception { public void tearDown() throws Exception {
client.disconnect(); client.disconnect();
} }
@Test(expected = JedisConnectionException.class) @Test(expected = JedisConnectionException.class)
public void checkUnkownHost() { public void checkUnkownHost() {
client.setHost("someunknownhost"); client.setHost("someunknownhost");
client.connect(); client.connect();
} }
@Test(expected = JedisConnectionException.class) @Test(expected = JedisConnectionException.class)
public void checkWrongPort() { public void checkWrongPort() {
client.setHost("localhost"); client.setHost("localhost");
client.setPort(55665); client.setPort(55665);
client.connect(); client.connect();
} }
@Test @Test
public void connectIfNotConnectedWhenSettingTimeoutInfinite() { public void connectIfNotConnectedWhenSettingTimeoutInfinite() {
client.setHost("localhost"); client.setHost("localhost");
client.setPort(6379); client.setPort(6379);
client.setTimeoutInfinite(); client.setTimeoutInfinite();
} }

20
src/test/java/redis/clients/jedis/tests/FragmentedByteArrayInputStream.java
View File

@@ -9,22 +9,22 @@ public class FragmentedByteArrayInputStream extends ByteArrayInputStream {
private int readMethodCallCount = 0; private int readMethodCallCount = 0;
public FragmentedByteArrayInputStream(final byte[] buf) { public FragmentedByteArrayInputStream(final byte[] buf) {
super(buf); super(buf);
} }
public synchronized int read(final byte[] b, final int off, final int len) { public synchronized int read(final byte[] b, final int off, final int len) {
readMethodCallCount++; readMethodCallCount++;
if (len <= 10) { if (len <= 10) {
// if the len <= 10, return as usual .. // if the len <= 10, return as usual ..
return super.read(b, off, len); return super.read(b, off, len);
} else { } else {
// else return the first half .. // else return the first half ..
return super.read(b, off, len / 2); return super.read(b, off, len / 2);
} }
} }
public int getReadMethodCallCount() { public int getReadMethodCallCount() {
return readMethodCallCount; return readMethodCallCount;
} }
} }

102
src/test/java/redis/clients/jedis/tests/JedisPoolTest.java
View File

@@ -11,6 +11,7 @@ import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.exceptions.JedisConnectionException; import redis.clients.jedis.exceptions.JedisConnectionException;
public class JedisPoolTest extends Assert { public class JedisPoolTest extends Assert {
@@ -18,59 +19,59 @@ public class JedisPoolTest extends Assert {
@Test @Test
public void checkConnections() { public void checkConnections() {
JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(), JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(),
hnp.getPort(), 2000); hnp.getPort(), 2000);
Jedis jedis = pool.getResource(); Jedis jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy(); pool.destroy();
} }
@Test @Test
public void checkConnectionWithDefaultPort() { public void checkConnectionWithDefaultPort() {
JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(), JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(),
hnp.getPort()); hnp.getPort());
Jedis jedis = pool.getResource(); Jedis jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy(); pool.destroy();
} }
@Test @Test
public void checkJedisIsReusedWhenReturned() { public void checkJedisIsReusedWhenReturned() {
JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(), JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(),
hnp.getPort()); hnp.getPort());
Jedis jedis = pool.getResource(); Jedis jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.set("foo", "0"); jedis.set("foo", "0");
pool.returnResource(jedis); pool.returnResource(jedis);
jedis = pool.getResource(); jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.incr("foo"); jedis.incr("foo");
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy(); pool.destroy();
} }
@Test @Test
public void checkPoolRepairedWhenJedisIsBroken() { public void checkPoolRepairedWhenJedisIsBroken() {
JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(), JedisPool pool = new JedisPool(new JedisPoolConfig(), hnp.getHost(),
hnp.getPort()); hnp.getPort());
Jedis jedis = pool.getResource(); Jedis jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.quit(); jedis.quit();
pool.returnBrokenResource(jedis); pool.returnBrokenResource(jedis);
jedis = pool.getResource(); jedis = pool.getResource();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.incr("foo"); jedis.incr("foo");
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy(); pool.destroy();
} }
@Test(expected = JedisConnectionException.class) @Test(expected = JedisConnectionException.class)
@@ -92,8 +93,8 @@ public class JedisPoolTest extends Assert {
public void securePool() { public void securePool() {
JedisPoolConfig config = new JedisPoolConfig(); JedisPoolConfig config = new JedisPoolConfig();
config.setTestOnBorrow(true); config.setTestOnBorrow(true);
JedisPool pool = new JedisPool(config, hnp.getHost(), hnp.getPort(), 2000, JedisPool pool = new JedisPool(config, hnp.getHost(), hnp.getPort(),
"foobared"); 2000, "foobared");
Jedis jedis = pool.getResource(); Jedis jedis = pool.getResource();
jedis.set("foo", "bar"); jedis.set("foo", "bar");
pool.returnResource(jedis); pool.returnResource(jedis);
@@ -176,4 +177,25 @@ public class JedisPoolTest extends Assert {
pool0.returnResource(jedis); pool0.returnResource(jedis);
pool0.destroy(); pool0.destroy();
} }
@Test
public void returnResourceShouldResetState() {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(1);
config.setBlockWhenExhausted(false);
JedisPool pool = new JedisPool(config, hnp.getHost(), hnp.getPort(),
2000, "foobared");
Jedis jedis = pool.getResource();
jedis.set("hello", "jedis");
Transaction t = jedis.multi();
t.set("hello", "world");
pool.returnResource(jedis);
Jedis jedis2 = pool.getResource();
assertTrue(jedis == jedis2);
assertEquals("jedis", jedis2.get("hello"));
pool.returnResource(jedis2);
pool.destroy();
}
} }

21
src/test/java/redis/clients/jedis/tests/JedisSentinelPoolTest.java
View File

@@ -13,6 +13,7 @@ import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub; import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.JedisSentinelPool; import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.Transaction;
public class JedisSentinelPoolTest extends JedisTestBase { public class JedisSentinelPoolTest extends JedisTestBase {
private static final String MASTER_NAME = "mymaster"; private static final String MASTER_NAME = "mymaster";
@@ -150,4 +151,24 @@ public class JedisSentinelPoolTest extends JedisTestBase {
} }
} }
@Test
public void returnResourceShouldResetState() {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(1);
config.setBlockWhenExhausted(false);
JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels,
config, 1000, "foobared", 2);
Jedis jedis = pool.getResource();
jedis.set("hello", "jedis");
Transaction t = jedis.multi();
t.set("hello", "world");
pool.returnResource(jedis);
Jedis jedis2 = pool.getResource();
assertTrue(jedis == jedis2);
assertEquals("jedis", jedis2.get("hello"));
pool.returnResource(jedis2);
pool.destroy();
}
} }

20
src/test/java/redis/clients/jedis/tests/JedisTestBase.java
View File

@@ -8,18 +8,18 @@ import org.junit.Assert;
public abstract class JedisTestBase extends Assert { public abstract class JedisTestBase extends Assert {
protected void assertEquals(List<byte[]> expected, List<byte[]> actual) { protected void assertEquals(List<byte[]> expected, List<byte[]> actual) {
assertEquals(expected.size(), actual.size()); assertEquals(expected.size(), actual.size());
for (int n = 0; n < expected.size(); n++) { for (int n = 0; n < expected.size(); n++) {
assertArrayEquals(expected.get(n), actual.get(n)); assertArrayEquals(expected.get(n), actual.get(n));
} }
} }
protected void assertEquals(Set<byte[]> expected, Set<byte[]> actual) { protected void assertEquals(Set<byte[]> expected, Set<byte[]> actual) {
assertEquals(expected.size(), actual.size()); assertEquals(expected.size(), actual.size());
Iterator<byte[]> iterator = expected.iterator(); Iterator<byte[]> iterator = expected.iterator();
Iterator<byte[]> iterator2 = actual.iterator(); Iterator<byte[]> iterator2 = actual.iterator();
while (iterator.hasNext() || iterator2.hasNext()) { while (iterator.hasNext() || iterator2.hasNext()) {
assertArrayEquals(iterator.next(), iterator2.next()); assertArrayEquals(iterator.next(), iterator2.next());
} }
} }
} }

476
src/test/java/redis/clients/jedis/tests/PipeliningTest.java
View File

@@ -27,307 +27,321 @@ public class PipeliningTest extends Assert {
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
jedis = new Jedis(hnp.getHost(), hnp.getPort(), 500); jedis = new Jedis(hnp.getHost(), hnp.getPort(), 500);
jedis.connect(); jedis.connect();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.flushAll(); jedis.flushAll();
} }
@Test @Test
public void pipeline() throws UnsupportedEncodingException { public void pipeline() throws UnsupportedEncodingException {
List<Object> results = jedis.pipelined(new PipelineBlock() { List<Object> results = jedis.pipelined(new PipelineBlock() {
public void execute() { public void execute() {
set("foo", "bar"); set("foo", "bar");
get("foo"); get("foo");
} }
}); });
assertEquals(2, results.size()); assertEquals(2, results.size());
assertEquals("OK", results.get(0)); assertEquals("OK", results.get(0));
assertEquals("bar", results.get(1)); assertEquals("bar", results.get(1));
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
p.set("foo", "bar"); p.set("foo", "bar");
p.get("foo"); p.get("foo");
results = p.syncAndReturnAll(); results = p.syncAndReturnAll();
assertEquals(2, results.size()); assertEquals(2, results.size());
assertEquals("OK", results.get(0)); assertEquals("OK", results.get(0));
assertEquals("bar", results.get(1)); assertEquals("bar", results.get(1));
} }
@Test @Test
public void pipelineResponse() { public void pipelineResponse() {
jedis.set("string", "foo"); jedis.set("string", "foo");
jedis.lpush("list", "foo"); jedis.lpush("list", "foo");
jedis.hset("hash", "foo", "bar"); jedis.hset("hash", "foo", "bar");
jedis.zadd("zset", 1, "foo"); jedis.zadd("zset", 1, "foo");
jedis.sadd("set", "foo"); jedis.sadd("set", "foo");
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
Response<String> string = p.get("string"); Response<String> string = p.get("string");
Response<String> list = p.lpop("list"); Response<String> list = p.lpop("list");
Response<String> hash = p.hget("hash", "foo"); Response<String> hash = p.hget("hash", "foo");
Response<Set<String>> zset = p.zrange("zset", 0, -1); Response<Set<String>> zset = p.zrange("zset", 0, -1);
Response<String> set = p.spop("set"); Response<String> set = p.spop("set");
Response<Boolean> blist = p.exists("list"); Response<Boolean> blist = p.exists("list");
Response<Double> zincrby = p.zincrby("zset", 1, "foo"); Response<Double> zincrby = p.zincrby("zset", 1, "foo");
Response<Long> zcard = p.zcard("zset"); Response<Long> zcard = p.zcard("zset");
p.lpush("list", "bar"); p.lpush("list", "bar");
Response<List<String>> lrange = p.lrange("list", 0, -1); Response<List<String>> lrange = p.lrange("list", 0, -1);
Response<Map<String, String>> hgetAll = p.hgetAll("hash"); Response<Map<String, String>> hgetAll = p.hgetAll("hash");
p.sadd("set", "foo"); p.sadd("set", "foo");
Response<Set<String>> smembers = p.smembers("set"); Response<Set<String>> smembers = p.smembers("set");
Response<Set<Tuple>> zrangeWithScores = p.zrangeWithScores("zset", 0, Response<Set<Tuple>> zrangeWithScores = p.zrangeWithScores("zset", 0,
-1); -1);
p.sync(); p.sync();
assertEquals("foo", string.get()); assertEquals("foo", string.get());
assertEquals("foo", list.get()); assertEquals("foo", list.get());
assertEquals("bar", hash.get()); assertEquals("bar", hash.get());
assertEquals("foo", zset.get().iterator().next()); assertEquals("foo", zset.get().iterator().next());
assertEquals("foo", set.get()); assertEquals("foo", set.get());
assertEquals(false, blist.get()); assertEquals(false, blist.get());
assertEquals(Double.valueOf(2), zincrby.get()); assertEquals(Double.valueOf(2), zincrby.get());
assertEquals(Long.valueOf(1), zcard.get()); assertEquals(Long.valueOf(1), zcard.get());
assertEquals(1, lrange.get().size()); assertEquals(1, lrange.get().size());
assertNotNull(hgetAll.get().get("foo")); assertNotNull(hgetAll.get().get("foo"));
assertEquals(1, smembers.get().size()); assertEquals(1, smembers.get().size());
assertEquals(1, zrangeWithScores.get().size()); assertEquals(1, zrangeWithScores.get().size());
} }
@Test @Test
public void pipelineResponseWithData() { public void pipelineResponseWithData() {
jedis.zadd("zset", 1, "foo"); jedis.zadd("zset", 1, "foo");
Pipeline p = jedis.pipelined();
Response<Double> score = p.zscore("zset", "foo");
p.sync();
assertNotNull(score.get()); Pipeline p = jedis.pipelined();
Response<Double> score = p.zscore("zset", "foo");
p.sync();
assertNotNull(score.get());
} }
@Test @Test
public void pipelineBinarySafeHashCommands() { public void pipelineBinarySafeHashCommands() {
jedis.hset("key".getBytes(), "f1".getBytes(), "v111".getBytes()); jedis.hset("key".getBytes(), "f1".getBytes(), "v111".getBytes());
jedis.hset("key".getBytes(), "f22".getBytes(), "v2222".getBytes()); jedis.hset("key".getBytes(), "f22".getBytes(), "v2222".getBytes());
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
Response<Map<byte[],byte[]>> fmap = p.hgetAll("key".getBytes()); Response<Map<byte[], byte[]>> fmap = p.hgetAll("key".getBytes());
Response<Set<byte[]>> fkeys = p.hkeys("key".getBytes()); Response<Set<byte[]>> fkeys = p.hkeys("key".getBytes());
Response<List<byte[]>> fordered = p.hmget("key".getBytes(), "f22".getBytes(), "f1".getBytes()); Response<List<byte[]>> fordered = p.hmget("key".getBytes(),
Response<List<byte[]>> fvals = p.hvals("key".getBytes()); "f22".getBytes(), "f1".getBytes());
p.sync(); Response<List<byte[]>> fvals = p.hvals("key".getBytes());
p.sync();
assertNotNull(fmap.get()); assertNotNull(fmap.get());
// we have to do these strange contortions because byte[] is not a very good key // we have to do these strange contortions because byte[] is not a very
// for a java Map. It only works with equality (you need the exact key object to retrieve // good key
// the value) I recommend we switch to using ByteBuffer or something similar: // for a java Map. It only works with equality (you need the exact key
// http://stackoverflow.com/questions/1058149/using-a-byte-array-as-hashmap-key-java // object to retrieve
Map<byte[],byte[]> map = fmap.get(); // the value) I recommend we switch to using ByteBuffer or something
Set<byte[]> mapKeys = map.keySet(); // similar:
Iterator<byte[]> iterMap = mapKeys.iterator(); // http://stackoverflow.com/questions/1058149/using-a-byte-array-as-hashmap-key-java
byte[] firstMapKey = iterMap.next(); Map<byte[], byte[]> map = fmap.get();
byte[] secondMapKey = iterMap.next(); Set<byte[]> mapKeys = map.keySet();
assertFalse(iterMap.hasNext()); Iterator<byte[]> iterMap = mapKeys.iterator();
verifyHasBothValues(firstMapKey, secondMapKey, "f1".getBytes(), "f22".getBytes()); byte[] firstMapKey = iterMap.next();
byte[] firstMapValue = map.get(firstMapKey); byte[] secondMapKey = iterMap.next();
byte[] secondMapValue = map.get(secondMapKey); assertFalse(iterMap.hasNext());
verifyHasBothValues(firstMapValue, secondMapValue, "v111".getBytes(), "v2222".getBytes()); verifyHasBothValues(firstMapKey, secondMapKey, "f1".getBytes(),
"f22".getBytes());
byte[] firstMapValue = map.get(firstMapKey);
byte[] secondMapValue = map.get(secondMapKey);
verifyHasBothValues(firstMapValue, secondMapValue, "v111".getBytes(),
"v2222".getBytes());
assertNotNull(fkeys.get()); assertNotNull(fkeys.get());
Iterator<byte[]> iter = fkeys.get().iterator(); Iterator<byte[]> iter = fkeys.get().iterator();
byte[] firstKey = iter.next(); byte[] firstKey = iter.next();
byte[] secondKey = iter.next(); byte[] secondKey = iter.next();
assertFalse(iter.hasNext()); assertFalse(iter.hasNext());
verifyHasBothValues(firstKey, secondKey, "f1".getBytes(), "f22".getBytes()); verifyHasBothValues(firstKey, secondKey, "f1".getBytes(),
"f22".getBytes());
assertNotNull(fordered.get()); assertNotNull(fordered.get());
assertArrayEquals("v2222".getBytes(), fordered.get().get(0)); assertArrayEquals("v2222".getBytes(), fordered.get().get(0));
assertArrayEquals("v111".getBytes(), fordered.get().get(1)); assertArrayEquals("v111".getBytes(), fordered.get().get(1));
assertNotNull(fvals.get()); assertNotNull(fvals.get());
assertEquals(2, fvals.get().size()); assertEquals(2, fvals.get().size());
byte[] firstValue = fvals.get().get(0); byte[] firstValue = fvals.get().get(0);
byte[] secondValue = fvals.get().get(1); byte[] secondValue = fvals.get().get(1);
verifyHasBothValues(firstValue, secondValue, "v111".getBytes(), "v2222".getBytes()); verifyHasBothValues(firstValue, secondValue, "v111".getBytes(),
"v2222".getBytes());
} }
private void verifyHasBothValues(byte[] firstKey, byte[] secondKey, byte[] value1, byte[] value2) { private void verifyHasBothValues(byte[] firstKey, byte[] secondKey,
assertFalse(Arrays.equals(firstKey, secondKey)); byte[] value1, byte[] value2) {
assertTrue(Arrays.equals(firstKey, value1) || Arrays.equals(firstKey, value2)); assertFalse(Arrays.equals(firstKey, secondKey));
assertTrue(Arrays.equals(secondKey, value1) || Arrays.equals(secondKey, value2)); assertTrue(Arrays.equals(firstKey, value1)
|| Arrays.equals(firstKey, value2));
assertTrue(Arrays.equals(secondKey, value1)
|| Arrays.equals(secondKey, value2));
} }
@Test @Test
public void pipelineSelect() { public void pipelineSelect() {
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
p.select(1); p.select(1);
p.sync(); p.sync();
} }
@Test @Test
public void pipelineResponseWithoutData() { public void pipelineResponseWithoutData() {
jedis.zadd("zset", 1, "foo"); jedis.zadd("zset", 1, "foo");
Pipeline p = jedis.pipelined();
Response<Double> score = p.zscore("zset", "bar");
p.sync();
assertNull(score.get()); Pipeline p = jedis.pipelined();
Response<Double> score = p.zscore("zset", "bar");
p.sync();
assertNull(score.get());
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void pipelineResponseWithinPipeline() { public void pipelineResponseWithinPipeline() {
jedis.set("string", "foo"); jedis.set("string", "foo");
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
Response<String> string = p.get("string"); Response<String> string = p.get("string");
string.get(); string.get();
p.sync(); p.sync();
} }
@Test @Test
public void pipelineWithPubSub() { public void pipelineWithPubSub() {
Pipeline pipelined = jedis.pipelined(); Pipeline pipelined = jedis.pipelined();
Response<Long> p1 = pipelined.publish("foo", "bar"); Response<Long> p1 = pipelined.publish("foo", "bar");
Response<Long> p2 = pipelined.publish("foo".getBytes(), "bar" Response<Long> p2 = pipelined.publish("foo".getBytes(),
.getBytes()); "bar".getBytes());
pipelined.sync(); pipelined.sync();
assertEquals(0, p1.get().longValue()); assertEquals(0, p1.get().longValue());
assertEquals(0, p2.get().longValue()); assertEquals(0, p2.get().longValue());
} }
@Test @Test
public void canRetrieveUnsetKey() { public void canRetrieveUnsetKey() {
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
Response<String> shouldNotExist = p.get(UUID.randomUUID().toString()); Response<String> shouldNotExist = p.get(UUID.randomUUID().toString());
p.sync(); p.sync();
assertNull(shouldNotExist.get()); assertNull(shouldNotExist.get());
}
@Test
public void piplineWithError(){
Pipeline p = jedis.pipelined();
p.set("foo", "bar");
Response<Set<String>> error = p.smembers("foo");
Response<String> r = p.get("foo");
p.sync();
try{
error.get();
fail();
}catch(JedisDataException e){
//that is fine we should be here
}
assertEquals(r.get(), "bar");
} }
@Test @Test
public void multi(){ public void piplineWithError() {
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
p.multi(); p.set("foo", "bar");
Response<Long> r1 = p.hincrBy("a", "f1", -1); Response<Set<String>> error = p.smembers("foo");
Response<Long> r2 = p.hincrBy("a", "f1", -2); Response<String> r = p.get("foo");
Response<List<Object>> r3 = p.exec(); p.sync();
List<Object> result = p.syncAndReturnAll(); try {
error.get();
assertEquals(new Long(-1), r1.get()); fail();
assertEquals(new Long(-3), r2.get()); } catch (JedisDataException e) {
// that is fine we should be here
assertEquals(4, result.size()); }
assertEquals(r.get(), "bar");
assertEquals("OK", result.get(0)); }
assertEquals("QUEUED", result.get(1));
assertEquals("QUEUED", result.get(2)); @Test
public void multi() {
//4th result is a list with the results from the multi Pipeline p = jedis.pipelined();
@SuppressWarnings("unchecked") p.multi();
List<Object> multiResult = (List<Object>) result.get(3); Response<Long> r1 = p.hincrBy("a", "f1", -1);
assertEquals(new Long(-1), multiResult.get(0)); Response<Long> r2 = p.hincrBy("a", "f1", -2);
assertEquals(new Long(-3), multiResult.get(1)); Response<List<Object>> r3 = p.exec();
List<Object> result = p.syncAndReturnAll();
assertEquals(new Long(-1), r3.get().get(0));
assertEquals(new Long(-3), r3.get().get(1)); assertEquals(new Long(-1), r1.get());
assertEquals(new Long(-3), r2.get());
assertEquals(4, result.size());
assertEquals("OK", result.get(0));
assertEquals("QUEUED", result.get(1));
assertEquals("QUEUED", result.get(2));
// 4th result is a list with the results from the multi
@SuppressWarnings("unchecked")
List<Object> multiResult = (List<Object>) result.get(3);
assertEquals(new Long(-1), multiResult.get(0));
assertEquals(new Long(-3), multiResult.get(1));
assertEquals(new Long(-1), r3.get().get(0));
assertEquals(new Long(-3), r3.get().get(1));
} }
@Test @Test
public void testDiscardInPipeline() { public void testDiscardInPipeline() {
Pipeline pipeline = jedis.pipelined(); Pipeline pipeline = jedis.pipelined();
pipeline.multi(); pipeline.multi();
pipeline.set("foo", "bar"); pipeline.set("foo", "bar");
Response<String> discard = pipeline.discard(); Response<String> discard = pipeline.discard();
Response<String> get = pipeline.get("foo"); Response<String> get = pipeline.get("foo");
pipeline.sync(); pipeline.sync();
discard.get(); discard.get();
get.get(); get.get();
} }
@Test
public void testEval() {
String script = "return 'success!'";
Pipeline p = jedis.pipelined(); @Test
Response<String> result = p.eval(script); public void testEval() {
p.sync(); String script = "return 'success!'";
assertEquals("success!", result.get()); Pipeline p = jedis.pipelined();
} Response<String> result = p.eval(script);
p.sync();
@Test assertEquals("success!", result.get());
public void testEvalKeyAndArg() { }
String key = "test";
String arg = "3";
String script = "redis.call('INCRBY', KEYS[1], ARGV[1]) redis.call('INCRBY', KEYS[1], ARGV[1])";
Pipeline p = jedis.pipelined(); @Test
p.set(key, "0"); public void testEvalKeyAndArg() {
Response<String> result0 = p.eval(script, Arrays.asList(key), Arrays.asList(arg)); String key = "test";
p.incr(key); String arg = "3";
Response<String> result1 = p.eval(script, Arrays.asList(key), Arrays.asList(arg)); String script = "redis.call('INCRBY', KEYS[1], ARGV[1]) redis.call('INCRBY', KEYS[1], ARGV[1])";
Response<String> result2 = p.get(key);
p.sync();
assertNull(result0.get()); Pipeline p = jedis.pipelined();
assertNull(result1.get()); p.set(key, "0");
assertEquals("13", result2.get()); Response<String> result0 = p.eval(script, Arrays.asList(key),
} Arrays.asList(arg));
p.incr(key);
Response<String> result1 = p.eval(script, Arrays.asList(key),
Arrays.asList(arg));
Response<String> result2 = p.get(key);
p.sync();
@Test assertNull(result0.get());
public void testEvalsha() { assertNull(result1.get());
String script = "return 'success!'"; assertEquals("13", result2.get());
String sha1 = jedis.scriptLoad(script); }
assertTrue(jedis.scriptExists(sha1)); @Test
public void testEvalsha() {
String script = "return 'success!'";
String sha1 = jedis.scriptLoad(script);
Pipeline p = jedis.pipelined(); assertTrue(jedis.scriptExists(sha1));
Response<String> result = p.evalsha(sha1);
p.sync();
assertEquals("success!", result.get()); Pipeline p = jedis.pipelined();
} Response<String> result = p.evalsha(sha1);
p.sync();
@Test assertEquals("success!", result.get());
public void testEvalshaKeyAndArg() { }
String key = "test";
String arg = "3";
String script = "redis.call('INCRBY', KEYS[1], ARGV[1]) redis.call('INCRBY', KEYS[1], ARGV[1])";
String sha1 = jedis.scriptLoad(script);
assertTrue(jedis.scriptExists(sha1)); @Test
public void testEvalshaKeyAndArg() {
String key = "test";
String arg = "3";
String script = "redis.call('INCRBY', KEYS[1], ARGV[1]) redis.call('INCRBY', KEYS[1], ARGV[1])";
String sha1 = jedis.scriptLoad(script);
Pipeline p = jedis.pipelined(); assertTrue(jedis.scriptExists(sha1));
p.set(key, "0");
Response<String> result0 = p.evalsha(sha1, Arrays.asList(key), Arrays.asList(arg));
p.incr(key);
Response<String> result1 = p.evalsha(sha1, Arrays.asList(key), Arrays.asList(arg));
Response<String> result2 = p.get(key);
p.sync();
assertNull(result0.get()); Pipeline p = jedis.pipelined();
assertNull(result1.get()); p.set(key, "0");
assertEquals("13", result2.get()); Response<String> result0 = p.evalsha(sha1, Arrays.asList(key),
} Arrays.asList(arg));
p.incr(key);
Response<String> result1 = p.evalsha(sha1, Arrays.asList(key),
Arrays.asList(arg));
Response<String> result2 = p.get(key);
p.sync();
assertNull(result0.get());
assertNull(result1.get());
assertEquals("13", result2.get());
}
} }

94
src/test/java/redis/clients/jedis/tests/ProtocolTest.java
View File

@@ -19,86 +19,86 @@ import redis.clients.util.SafeEncoder;
public class ProtocolTest extends JedisTestBase { public class ProtocolTest extends JedisTestBase {
@Test @Test
public void buildACommand() throws IOException { public void buildACommand() throws IOException {
PipedInputStream pis = new PipedInputStream(); PipedInputStream pis = new PipedInputStream();
BufferedInputStream bis = new BufferedInputStream(pis); BufferedInputStream bis = new BufferedInputStream(pis);
PipedOutputStream pos = new PipedOutputStream(pis); PipedOutputStream pos = new PipedOutputStream(pis);
RedisOutputStream ros = new RedisOutputStream(pos); RedisOutputStream ros = new RedisOutputStream(pos);
Protocol.sendCommand(ros, Protocol.Command.GET, Protocol.sendCommand(ros, Protocol.Command.GET,
"SOMEKEY".getBytes(Protocol.CHARSET)); "SOMEKEY".getBytes(Protocol.CHARSET));
ros.flush(); ros.flush();
pos.close(); pos.close();
String expectedCommand = "*2\r\n$3\r\nGET\r\n$7\r\nSOMEKEY\r\n"; String expectedCommand = "*2\r\n$3\r\nGET\r\n$7\r\nSOMEKEY\r\n";
int b; int b;
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
while ((b = bis.read()) != -1) { while ((b = bis.read()) != -1) {
sb.append((char) b); sb.append((char) b);
} }
assertEquals(expectedCommand, sb.toString()); assertEquals(expectedCommand, sb.toString());
} }
@Test @Test
public void bulkReply() { public void bulkReply() {
InputStream is = new ByteArrayInputStream("$6\r\nfoobar\r\n".getBytes()); InputStream is = new ByteArrayInputStream("$6\r\nfoobar\r\n".getBytes());
byte[] response = (byte[]) Protocol.read(new RedisInputStream(is)); byte[] response = (byte[]) Protocol.read(new RedisInputStream(is));
assertArrayEquals(SafeEncoder.encode("foobar"), response); assertArrayEquals(SafeEncoder.encode("foobar"), response);
} }
@Test @Test
public void fragmentedBulkReply() { public void fragmentedBulkReply() {
FragmentedByteArrayInputStream fis = new FragmentedByteArrayInputStream( FragmentedByteArrayInputStream fis = new FragmentedByteArrayInputStream(
"$30\r\n012345678901234567890123456789\r\n".getBytes()); "$30\r\n012345678901234567890123456789\r\n".getBytes());
byte[] response = (byte[]) Protocol.read(new RedisInputStream(fis)); byte[] response = (byte[]) Protocol.read(new RedisInputStream(fis));
assertArrayEquals(SafeEncoder.encode("012345678901234567890123456789"), assertArrayEquals(SafeEncoder.encode("012345678901234567890123456789"),
response); response);
} }
@Test @Test
public void nullBulkReply() { public void nullBulkReply() {
InputStream is = new ByteArrayInputStream("$-1\r\n".getBytes()); InputStream is = new ByteArrayInputStream("$-1\r\n".getBytes());
String response = (String) Protocol.read(new RedisInputStream(is)); String response = (String) Protocol.read(new RedisInputStream(is));
assertEquals(null, response); assertEquals(null, response);
} }
@Test @Test
public void singleLineReply() { public void singleLineReply() {
InputStream is = new ByteArrayInputStream("+OK\r\n".getBytes()); InputStream is = new ByteArrayInputStream("+OK\r\n".getBytes());
byte[] response = (byte[]) Protocol.read(new RedisInputStream(is)); byte[] response = (byte[]) Protocol.read(new RedisInputStream(is));
assertArrayEquals(SafeEncoder.encode("OK"), response); assertArrayEquals(SafeEncoder.encode("OK"), response);
} }
@Test @Test
public void integerReply() { public void integerReply() {
InputStream is = new ByteArrayInputStream(":123\r\n".getBytes()); InputStream is = new ByteArrayInputStream(":123\r\n".getBytes());
long response = (Long) Protocol.read(new RedisInputStream(is)); long response = (Long) Protocol.read(new RedisInputStream(is));
assertEquals(123, response); assertEquals(123, response);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Test @Test
public void multiBulkReply() { public void multiBulkReply() {
InputStream is = new ByteArrayInputStream( InputStream is = new ByteArrayInputStream(
"*4\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$5\r\nHello\r\n$5\r\nWorld\r\n" "*4\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$5\r\nHello\r\n$5\r\nWorld\r\n"
.getBytes()); .getBytes());
List<byte[]> response = (List<byte[]>) Protocol List<byte[]> response = (List<byte[]>) Protocol
.read(new RedisInputStream(is)); .read(new RedisInputStream(is));
List<byte[]> expected = new ArrayList<byte[]>(); List<byte[]> expected = new ArrayList<byte[]>();
expected.add(SafeEncoder.encode("foo")); expected.add(SafeEncoder.encode("foo"));
expected.add(SafeEncoder.encode("bar")); expected.add(SafeEncoder.encode("bar"));
expected.add(SafeEncoder.encode("Hello")); expected.add(SafeEncoder.encode("Hello"));
expected.add(SafeEncoder.encode("World")); expected.add(SafeEncoder.encode("World"));
assertEquals(expected, response); assertEquals(expected, response);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Test @Test
public void nullMultiBulkReply() { public void nullMultiBulkReply() {
InputStream is = new ByteArrayInputStream("*-1\r\n".getBytes()); InputStream is = new ByteArrayInputStream("*-1\r\n".getBytes());
List<String> response = (List<String>) Protocol List<String> response = (List<String>) Protocol
.read(new RedisInputStream(is)); .read(new RedisInputStream(is));
assertNull(response); assertNull(response);
} }
} }

442
src/test/java/redis/clients/jedis/tests/ShardedJedisTest.java
View File

@@ -18,286 +18,288 @@ import redis.clients.util.Sharded;
public class ShardedJedisTest extends Assert { public class ShardedJedisTest extends Assert {
private static HostAndPort redis1 = HostAndPortUtil.getRedisServers() private static HostAndPort redis1 = HostAndPortUtil.getRedisServers()
.get(0); .get(0);
private static HostAndPort redis2 = HostAndPortUtil.getRedisServers() private static HostAndPort redis2 = HostAndPortUtil.getRedisServers()
.get(1); .get(1);
private List<String> getKeysDifferentShard(ShardedJedis jedis) { private List<String> getKeysDifferentShard(ShardedJedis jedis) {
List<String> ret = new ArrayList<String>(); List<String> ret = new ArrayList<String>();
JedisShardInfo first = jedis.getShardInfo("a0"); JedisShardInfo first = jedis.getShardInfo("a0");
ret.add("a0"); ret.add("a0");
for (int i = 1; i < 100; ++i) { for (int i = 1; i < 100; ++i) {
JedisShardInfo actual = jedis.getShardInfo("a" + i); JedisShardInfo actual = jedis.getShardInfo("a" + i);
if (actual != first) { if (actual != first) {
ret.add("a" + i); ret.add("a" + i);
break; break;
} }
} }
return ret; return ret;
} }
@Test @Test
public void checkSharding() { public void checkSharding() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort())); shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort()));
shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort())); shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort()));
ShardedJedis jedis = new ShardedJedis(shards); ShardedJedis jedis = new ShardedJedis(shards);
List<String> keys = getKeysDifferentShard(jedis); List<String> keys = getKeysDifferentShard(jedis);
JedisShardInfo s1 = jedis.getShardInfo(keys.get(0)); JedisShardInfo s1 = jedis.getShardInfo(keys.get(0));
JedisShardInfo s2 = jedis.getShardInfo(keys.get(1)); JedisShardInfo s2 = jedis.getShardInfo(keys.get(1));
assertNotSame(s1, s2); assertNotSame(s1, s2);
} }
@Test @Test
public void trySharding() { public void trySharding() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo si = new JedisShardInfo(redis1.getHost(), redis1.getPort()); JedisShardInfo si = new JedisShardInfo(redis1.getHost(),
si.setPassword("foobared"); redis1.getPort());
shards.add(si); si.setPassword("foobared");
si = new JedisShardInfo(redis2.getHost(), redis2.getPort()); shards.add(si);
si.setPassword("foobared"); si = new JedisShardInfo(redis2.getHost(), redis2.getPort());
shards.add(si); si.setPassword("foobared");
ShardedJedis jedis = new ShardedJedis(shards); shards.add(si);
jedis.set("a", "bar"); ShardedJedis jedis = new ShardedJedis(shards);
JedisShardInfo s1 = jedis.getShardInfo("a"); jedis.set("a", "bar");
jedis.set("b", "bar1"); JedisShardInfo s1 = jedis.getShardInfo("a");
JedisShardInfo s2 = jedis.getShardInfo("b"); jedis.set("b", "bar1");
jedis.disconnect(); JedisShardInfo s2 = jedis.getShardInfo("b");
jedis.disconnect();
Jedis j = new Jedis(s1.getHost(), s1.getPort()); Jedis j = new Jedis(s1.getHost(), s1.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar", j.get("a")); assertEquals("bar", j.get("a"));
j.disconnect(); j.disconnect();
j = new Jedis(s2.getHost(), s2.getPort()); j = new Jedis(s2.getHost(), s2.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar1", j.get("b")); assertEquals("bar1", j.get("b"));
j.disconnect(); j.disconnect();
} }
@Test @Test
public void tryShardingWithMurmure() { public void tryShardingWithMurmure() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo si = new JedisShardInfo(redis1.getHost(), redis1.getPort()); JedisShardInfo si = new JedisShardInfo(redis1.getHost(),
si.setPassword("foobared"); redis1.getPort());
shards.add(si); si.setPassword("foobared");
si = new JedisShardInfo(redis2.getHost(), redis2.getPort()); shards.add(si);
si.setPassword("foobared"); si = new JedisShardInfo(redis2.getHost(), redis2.getPort());
shards.add(si); si.setPassword("foobared");
ShardedJedis jedis = new ShardedJedis(shards, Hashing.MURMUR_HASH); shards.add(si);
jedis.set("a", "bar"); ShardedJedis jedis = new ShardedJedis(shards, Hashing.MURMUR_HASH);
JedisShardInfo s1 = jedis.getShardInfo("a"); jedis.set("a", "bar");
jedis.set("b", "bar1"); JedisShardInfo s1 = jedis.getShardInfo("a");
JedisShardInfo s2 = jedis.getShardInfo("b"); jedis.set("b", "bar1");
jedis.disconnect(); JedisShardInfo s2 = jedis.getShardInfo("b");
jedis.disconnect();
Jedis j = new Jedis(s1.getHost(), s1.getPort()); Jedis j = new Jedis(s1.getHost(), s1.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar", j.get("a")); assertEquals("bar", j.get("a"));
j.disconnect(); j.disconnect();
j = new Jedis(s2.getHost(), s2.getPort()); j = new Jedis(s2.getHost(), s2.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar1", j.get("b")); assertEquals("bar1", j.get("b"));
j.disconnect(); j.disconnect();
} }
@Test @Test
public void checkKeyTags() { public void checkKeyTags() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort())); shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort()));
shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort())); shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort()));
ShardedJedis jedis = new ShardedJedis(shards, ShardedJedis jedis = new ShardedJedis(shards,
ShardedJedis.DEFAULT_KEY_TAG_PATTERN); ShardedJedis.DEFAULT_KEY_TAG_PATTERN);
assertEquals(jedis.getKeyTag("foo"), "foo"); assertEquals(jedis.getKeyTag("foo"), "foo");
assertEquals(jedis.getKeyTag("foo{bar}"), "bar"); assertEquals(jedis.getKeyTag("foo{bar}"), "bar");
assertEquals(jedis.getKeyTag("foo{bar}}"), "bar"); // default pattern is assertEquals(jedis.getKeyTag("foo{bar}}"), "bar"); // default pattern is
// non greedy // non greedy
assertEquals(jedis.getKeyTag("{bar}foo"), "bar"); // Key tag may appear assertEquals(jedis.getKeyTag("{bar}foo"), "bar"); // Key tag may appear
// anywhere // anywhere
assertEquals(jedis.getKeyTag("f{bar}oo"), "bar"); // Key tag may appear assertEquals(jedis.getKeyTag("f{bar}oo"), "bar"); // Key tag may appear
// anywhere // anywhere
JedisShardInfo s1 = jedis.getShardInfo("abc{bar}"); JedisShardInfo s1 = jedis.getShardInfo("abc{bar}");
JedisShardInfo s2 = jedis.getShardInfo("foo{bar}"); JedisShardInfo s2 = jedis.getShardInfo("foo{bar}");
assertSame(s1, s2); assertSame(s1, s2);
List<String> keys = getKeysDifferentShard(jedis); List<String> keys = getKeysDifferentShard(jedis);
JedisShardInfo s3 = jedis.getShardInfo(keys.get(0)); JedisShardInfo s3 = jedis.getShardInfo(keys.get(0));
JedisShardInfo s4 = jedis.getShardInfo(keys.get(1)); JedisShardInfo s4 = jedis.getShardInfo(keys.get(1));
assertNotSame(s3, s4); assertNotSame(s3, s4);
ShardedJedis jedis2 = new ShardedJedis(shards); ShardedJedis jedis2 = new ShardedJedis(shards);
assertEquals(jedis2.getKeyTag("foo"), "foo"); assertEquals(jedis2.getKeyTag("foo"), "foo");
assertNotSame(jedis2.getKeyTag("foo{bar}"), "bar"); assertNotSame(jedis2.getKeyTag("foo{bar}"), "bar");
JedisShardInfo s5 = jedis2.getShardInfo(keys.get(0) + "{bar}"); JedisShardInfo s5 = jedis2.getShardInfo(keys.get(0) + "{bar}");
JedisShardInfo s6 = jedis2.getShardInfo(keys.get(1) + "{bar}"); JedisShardInfo s6 = jedis2.getShardInfo(keys.get(1) + "{bar}");
assertNotSame(s5, s6); assertNotSame(s5, s6);
} }
@Test @Test
public void shardedPipeline() { public void shardedPipeline() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort())); shards.add(new JedisShardInfo(redis1.getHost(), redis1.getPort()));
shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort())); shards.add(new JedisShardInfo(redis2.getHost(), redis2.getPort()));
shards.get(0).setPassword("foobared"); shards.get(0).setPassword("foobared");
shards.get(1).setPassword("foobared"); shards.get(1).setPassword("foobared");
ShardedJedis jedis = new ShardedJedis(shards); ShardedJedis jedis = new ShardedJedis(shards);
final List<String> keys = getKeysDifferentShard(jedis); final List<String> keys = getKeysDifferentShard(jedis);
jedis.set(keys.get(0), "a"); jedis.set(keys.get(0), "a");
jedis.set(keys.get(1), "b"); jedis.set(keys.get(1), "b");
assertNotSame(jedis.getShard(keys.get(0)), jedis.getShard(keys.get(1))); assertNotSame(jedis.getShard(keys.get(0)), jedis.getShard(keys.get(1)));
List<Object> results = jedis.pipelined(new ShardedJedisPipeline() { List<Object> results = jedis.pipelined(new ShardedJedisPipeline() {
public void execute() { public void execute() {
get(keys.get(0)); get(keys.get(0));
get(keys.get(1)); get(keys.get(1));
} }
}); });
List<Object> expected = new ArrayList<Object>(2); List<Object> expected = new ArrayList<Object>(2);
expected.add(SafeEncoder.encode("a")); expected.add(SafeEncoder.encode("a"));
expected.add(SafeEncoder.encode("b")); expected.add(SafeEncoder.encode("b"));
assertEquals(2, results.size()); assertEquals(2, results.size());
assertArrayEquals(SafeEncoder.encode("a"), (byte[]) results.get(0)); assertArrayEquals(SafeEncoder.encode("a"), (byte[]) results.get(0));
assertArrayEquals(SafeEncoder.encode("b"), (byte[]) results.get(1)); assertArrayEquals(SafeEncoder.encode("b"), (byte[]) results.get(1));
} }
@Test @Test
public void testMD5Sharding() { public void testMD5Sharding() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3);
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2));
Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>(
shards, Hashing.MD5); shards, Hashing.MD5);
int shard_6379 = 0; int shard_6379 = 0;
int shard_6380 = 0; int shard_6380 = 0;
int shard_6381 = 0; int shard_6381 = 0;
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer
.toString(i)); .toString(i));
switch (jedisShardInfo.getPort()) { switch (jedisShardInfo.getPort()) {
case 6379: case 6379:
shard_6379++; shard_6379++;
break; break;
case 6380: case 6380:
shard_6380++; shard_6380++;
break; break;
case 6381: case 6381:
shard_6381++; shard_6381++;
break; break;
default: default:
fail("Attempting to use a non-defined shard!!:" fail("Attempting to use a non-defined shard!!:"
+ jedisShardInfo); + jedisShardInfo);
break; break;
} }
} }
assertTrue(shard_6379 > 300 && shard_6379 < 400); assertTrue(shard_6379 > 300 && shard_6379 < 400);
assertTrue(shard_6380 > 300 && shard_6380 < 400); assertTrue(shard_6380 > 300 && shard_6380 < 400);
assertTrue(shard_6381 > 300 && shard_6381 < 400); assertTrue(shard_6381 > 300 && shard_6381 < 400);
} }
@Test @Test
public void testMurmurSharding() { public void testMurmurSharding() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3);
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2));
Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>(
shards, Hashing.MURMUR_HASH); shards, Hashing.MURMUR_HASH);
int shard_6379 = 0; int shard_6379 = 0;
int shard_6380 = 0; int shard_6380 = 0;
int shard_6381 = 0; int shard_6381 = 0;
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer
.toString(i)); .toString(i));
switch (jedisShardInfo.getPort()) { switch (jedisShardInfo.getPort()) {
case 6379: case 6379:
shard_6379++; shard_6379++;
break; break;
case 6380: case 6380:
shard_6380++; shard_6380++;
break; break;
case 6381: case 6381:
shard_6381++; shard_6381++;
break; break;
default: default:
fail("Attempting to use a non-defined shard!!:" fail("Attempting to use a non-defined shard!!:"
+ jedisShardInfo); + jedisShardInfo);
break; break;
} }
} }
assertTrue(shard_6379 > 300 && shard_6379 < 400); assertTrue(shard_6379 > 300 && shard_6379 < 400);
assertTrue(shard_6380 > 300 && shard_6380 < 400); assertTrue(shard_6380 > 300 && shard_6380 < 400);
assertTrue(shard_6381 > 300 && shard_6381 < 400); assertTrue(shard_6381 > 300 && shard_6381 < 400);
} }
@Test @Test
public void testMasterSlaveShardingConsistency() { public void testMasterSlaveShardingConsistency() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3);
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2)); shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2));
Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>(
shards, Hashing.MURMUR_HASH); shards, Hashing.MURMUR_HASH);
List<JedisShardInfo> otherShards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> otherShards = new ArrayList<JedisShardInfo>(3);
otherShards.add(new JedisShardInfo("otherhost", Protocol.DEFAULT_PORT)); otherShards.add(new JedisShardInfo("otherhost", Protocol.DEFAULT_PORT));
otherShards.add(new JedisShardInfo("otherhost", otherShards.add(new JedisShardInfo("otherhost",
Protocol.DEFAULT_PORT + 1)); Protocol.DEFAULT_PORT + 1));
otherShards.add(new JedisShardInfo("otherhost", otherShards.add(new JedisShardInfo("otherhost",
Protocol.DEFAULT_PORT + 2)); Protocol.DEFAULT_PORT + 2));
Sharded<Jedis, JedisShardInfo> sharded2 = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded2 = new Sharded<Jedis, JedisShardInfo>(
otherShards, Hashing.MURMUR_HASH); otherShards, Hashing.MURMUR_HASH);
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer
.toString(i)); .toString(i));
JedisShardInfo jedisShardInfo2 = sharded2.getShardInfo(Integer JedisShardInfo jedisShardInfo2 = sharded2.getShardInfo(Integer
.toString(i)); .toString(i));
assertEquals(shards.indexOf(jedisShardInfo), otherShards assertEquals(shards.indexOf(jedisShardInfo),
.indexOf(jedisShardInfo2)); otherShards.indexOf(jedisShardInfo2));
} }
} }
@Test @Test
public void testMasterSlaveShardingConsistencyWithShardNaming() { public void testMasterSlaveShardingConsistencyWithShardNaming() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(3);
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT, shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT,
"HOST1:1234")); "HOST1:1234"));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1, shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 1,
"HOST2:1234")); "HOST2:1234"));
shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2, shards.add(new JedisShardInfo("localhost", Protocol.DEFAULT_PORT + 2,
"HOST3:1234")); "HOST3:1234"));
Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded = new Sharded<Jedis, JedisShardInfo>(
shards, Hashing.MURMUR_HASH); shards, Hashing.MURMUR_HASH);
List<JedisShardInfo> otherShards = new ArrayList<JedisShardInfo>(3); List<JedisShardInfo> otherShards = new ArrayList<JedisShardInfo>(3);
otherShards.add(new JedisShardInfo("otherhost", Protocol.DEFAULT_PORT, otherShards.add(new JedisShardInfo("otherhost", Protocol.DEFAULT_PORT,
"HOST2:1234")); "HOST2:1234"));
otherShards.add(new JedisShardInfo("otherhost", otherShards.add(new JedisShardInfo("otherhost",
Protocol.DEFAULT_PORT + 1, "HOST3:1234")); Protocol.DEFAULT_PORT + 1, "HOST3:1234"));
otherShards.add(new JedisShardInfo("otherhost", otherShards.add(new JedisShardInfo("otherhost",
Protocol.DEFAULT_PORT + 2, "HOST1:1234")); Protocol.DEFAULT_PORT + 2, "HOST1:1234"));
Sharded<Jedis, JedisShardInfo> sharded2 = new Sharded<Jedis, JedisShardInfo>( Sharded<Jedis, JedisShardInfo> sharded2 = new Sharded<Jedis, JedisShardInfo>(
otherShards, Hashing.MURMUR_HASH); otherShards, Hashing.MURMUR_HASH);
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer JedisShardInfo jedisShardInfo = sharded.getShardInfo(Integer
.toString(i)); .toString(i));
JedisShardInfo jedisShardInfo2 = sharded2.getShardInfo(Integer JedisShardInfo jedisShardInfo2 = sharded2.getShardInfo(Integer
.toString(i)); .toString(i));
assertEquals(jedisShardInfo.getName(), jedisShardInfo2.getName()); assertEquals(jedisShardInfo.getName(), jedisShardInfo2.getName());
} }
} }
} }

2
src/test/java/redis/clients/jedis/tests/benchmark/GetSetBenchmark.java
View File

@@ -9,7 +9,7 @@ import redis.clients.jedis.Jedis;
import redis.clients.jedis.tests.HostAndPortUtil; import redis.clients.jedis.tests.HostAndPortUtil;
public class GetSetBenchmark { public class GetSetBenchmark {
private static HostAndPort hnp = HostAndPortUtil.getRedisServers().get(0); private static HostAndPort hnp = HostAndPortUtil.getRedisServers().get(0);
private static final int TOTAL_OPERATIONS = 100000; private static final int TOTAL_OPERATIONS = 100000;
public static void main(String[] args) throws UnknownHostException, public static void main(String[] args) throws UnknownHostException,

45
src/test/java/redis/clients/jedis/tests/benchmark/HashingBenchmark.java
View File

@@ -19,32 +19,33 @@ public class HashingBenchmark {
private static final int TOTAL_OPERATIONS = 100000; private static final int TOTAL_OPERATIONS = 100000;
public static void main(String[] args) throws UnknownHostException, public static void main(String[] args) throws UnknownHostException,
IOException { IOException {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo shard = new JedisShardInfo(hnp1.getHost(), hnp1.getPort()); JedisShardInfo shard = new JedisShardInfo(hnp1.getHost(),
shard.setPassword("foobared"); hnp1.getPort());
shards.add(shard); shard.setPassword("foobared");
shard = new JedisShardInfo(hnp2.getHost(), hnp2.getPort()); shards.add(shard);
shard.setPassword("foobared"); shard = new JedisShardInfo(hnp2.getHost(), hnp2.getPort());
shards.add(shard); shard.setPassword("foobared");
ShardedJedis jedis = new ShardedJedis(shards); shards.add(shard);
Collection<Jedis> allShards = jedis.getAllShards(); ShardedJedis jedis = new ShardedJedis(shards);
for (Jedis j : allShards) { Collection<Jedis> allShards = jedis.getAllShards();
j.flushAll(); for (Jedis j : allShards) {
} j.flushAll();
}
long begin = Calendar.getInstance().getTimeInMillis(); long begin = Calendar.getInstance().getTimeInMillis();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
String key = "foo" + n; String key = "foo" + n;
jedis.set(key, "bar" + n); jedis.set(key, "bar" + n);
jedis.get(key); jedis.get(key);
} }
long elapsed = Calendar.getInstance().getTimeInMillis() - begin; long elapsed = Calendar.getInstance().getTimeInMillis() - begin;
jedis.disconnect(); jedis.disconnect();
System.out.println(((1000 * 2 * TOTAL_OPERATIONS) / elapsed) + " ops"); System.out.println(((1000 * 2 * TOTAL_OPERATIONS) / elapsed) + " ops");
} }
} }

32
src/test/java/redis/clients/jedis/tests/benchmark/PipelinedGetSetBenchmark.java
View File

@@ -14,26 +14,26 @@ public class PipelinedGetSetBenchmark {
private static final int TOTAL_OPERATIONS = 200000; private static final int TOTAL_OPERATIONS = 200000;
public static void main(String[] args) throws UnknownHostException, public static void main(String[] args) throws UnknownHostException,
IOException { IOException {
Jedis jedis = new Jedis(hnp.getHost(), hnp.getPort()); Jedis jedis = new Jedis(hnp.getHost(), hnp.getPort());
jedis.connect(); jedis.connect();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.flushAll(); jedis.flushAll();
long begin = Calendar.getInstance().getTimeInMillis(); long begin = Calendar.getInstance().getTimeInMillis();
Pipeline p = jedis.pipelined(); Pipeline p = jedis.pipelined();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
String key = "foo" + n; String key = "foo" + n;
p.set(key, "bar" + n); p.set(key, "bar" + n);
p.get(key); p.get(key);
} }
p.sync(); p.sync();
long elapsed = Calendar.getInstance().getTimeInMillis() - begin; long elapsed = Calendar.getInstance().getTimeInMillis() - begin;
jedis.disconnect(); jedis.disconnect();
System.out.println(((1000 * 2 * TOTAL_OPERATIONS) / elapsed) + " ops"); System.out.println(((1000 * 2 * TOTAL_OPERATIONS) / elapsed) + " ops");
} }
} }

32
src/test/java/redis/clients/jedis/tests/benchmark/SafeEncoderBenchmark.java
View File

@@ -10,29 +10,29 @@ public class SafeEncoderBenchmark {
private static final int TOTAL_OPERATIONS = 10000000; private static final int TOTAL_OPERATIONS = 10000000;
public static void main(String[] args) throws UnknownHostException, public static void main(String[] args) throws UnknownHostException,
IOException { IOException {
long begin = Calendar.getInstance().getTimeInMillis(); long begin = Calendar.getInstance().getTimeInMillis();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
SafeEncoder.encode("foo bar!"); SafeEncoder.encode("foo bar!");
} }
long elapsed = Calendar.getInstance().getTimeInMillis() - begin; long elapsed = Calendar.getInstance().getTimeInMillis() - begin;
System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed) System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed)
+ " ops to build byte[]"); + " ops to build byte[]");
begin = Calendar.getInstance().getTimeInMillis(); begin = Calendar.getInstance().getTimeInMillis();
byte[] bytes = "foo bar!".getBytes(); byte[] bytes = "foo bar!".getBytes();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
SafeEncoder.encode(bytes); SafeEncoder.encode(bytes);
} }
elapsed = Calendar.getInstance().getTimeInMillis() - begin; elapsed = Calendar.getInstance().getTimeInMillis() - begin;
System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed) System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed)
+ " ops to build Strings"); + " ops to build Strings");
} }
} }

32
src/test/java/redis/clients/jedis/tests/benchmark/ShardedBenchmark.java
View File

@@ -10,30 +10,30 @@ public class ShardedBenchmark {
private static final int TOTAL_OPERATIONS = 10000000; private static final int TOTAL_OPERATIONS = 10000000;
public static void main(String[] args) throws UnknownHostException, public static void main(String[] args) throws UnknownHostException,
IOException { IOException {
long begin = Calendar.getInstance().getTimeInMillis(); long begin = Calendar.getInstance().getTimeInMillis();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
String key = "foo" + n; String key = "foo" + n;
Hashing.MD5.hash(key); Hashing.MD5.hash(key);
} }
long elapsed = Calendar.getInstance().getTimeInMillis() - begin; long elapsed = Calendar.getInstance().getTimeInMillis() - begin;
System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed) + " MD5 ops"); System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed) + " MD5 ops");
begin = Calendar.getInstance().getTimeInMillis(); begin = Calendar.getInstance().getTimeInMillis();
for (int n = 0; n <= TOTAL_OPERATIONS; n++) { for (int n = 0; n <= TOTAL_OPERATIONS; n++) {
String key = "foo" + n; String key = "foo" + n;
Hashing.MURMUR_HASH.hash(key); Hashing.MURMUR_HASH.hash(key);
} }
elapsed = Calendar.getInstance().getTimeInMillis() - begin; elapsed = Calendar.getInstance().getTimeInMillis() - begin;
System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed) System.out.println(((1000 * TOTAL_OPERATIONS) / elapsed)
+ " Murmur ops"); + " Murmur ops");
} }
} }

286
src/test/java/redis/clients/jedis/tests/commands/BinaryValuesCommandsTest.java
View File

@@ -1,19 +1,20 @@
package redis.clients.jedis.tests.commands; package redis.clients.jedis.tests.commands;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Protocol.Keyword;
import redis.clients.jedis.exceptions.JedisDataException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Protocol.Keyword;
import redis.clients.jedis.exceptions.JedisDataException;
public class BinaryValuesCommandsTest extends JedisCommandTestBase { public class BinaryValuesCommandsTest extends JedisCommandTestBase {
byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
byte[] bbar = { 0x05, 0x06, 0x07, 0x08 }; byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
byte[] bxx = { 0x78, 0x78 }; byte[] bxx = { 0x78, 0x78 };
byte[] bnx = { 0x6E, 0x78 }; byte[] bnx = { 0x6E, 0x78 };
byte[] bex = { 0x65, 0x78 }; byte[] bex = { 0x65, 0x78 };
byte[] bpx = { 0x70, 0x78 }; byte[] bpx = { 0x70, 0x78 };
long expireSeconds = 2; long expireSeconds = 2;
@@ -22,261 +23,260 @@ public class BinaryValuesCommandsTest extends JedisCommandTestBase {
@Before @Before
public void startUp() { public void startUp() {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
for (int n = 0; n < 1000; n++) { for (int n = 0; n < 1000; n++) {
sb.append("A"); sb.append("A");
} }
binaryValue = sb.toString().getBytes(); binaryValue = sb.toString().getBytes();
} }
@Test @Test
public void setAndGet() { public void setAndGet() {
String status = jedis.set(bfoo, binaryValue); String status = jedis.set(bfoo, binaryValue);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
byte[] value = jedis.get(bfoo); byte[] value = jedis.get(bfoo);
assertTrue(Arrays.equals(binaryValue, value)); assertTrue(Arrays.equals(binaryValue, value));
assertNull(jedis.get(bbar)); assertNull(jedis.get(bbar));
} }
@Test @Test
public void setNxExAndGet() { public void setNxExAndGet() {
String status = jedis.set(bfoo, binaryValue, bnx, bex, expireSeconds); String status = jedis.set(bfoo, binaryValue, bnx, bex, expireSeconds);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
byte[] value = jedis.get(bfoo); byte[] value = jedis.get(bfoo);
assertTrue(Arrays.equals(binaryValue, value)); assertTrue(Arrays.equals(binaryValue, value));
assertNull(jedis.get(bbar)); assertNull(jedis.get(bbar));
} }
@Test @Test
public void setIfNotExistAndGet() { public void setIfNotExistAndGet() {
String status= jedis.set(bfoo, binaryValue); String status = jedis.set(bfoo, binaryValue);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
// nx should fail if value exists // nx should fail if value exists
String statusFail = jedis.set(bfoo, binaryValue, bnx, bex, expireSeconds); String statusFail = jedis.set(bfoo, binaryValue, bnx, bex,
assertNull(statusFail); expireSeconds);
assertNull(statusFail);
byte[] value = jedis.get(bfoo); byte[] value = jedis.get(bfoo);
assertTrue(Arrays.equals(binaryValue, value)); assertTrue(Arrays.equals(binaryValue, value));
assertNull(jedis.get(bbar)); assertNull(jedis.get(bbar));
} }
@Test @Test
public void setIfExistAndGet() { public void setIfExistAndGet() {
String status= jedis.set(bfoo, binaryValue); String status = jedis.set(bfoo, binaryValue);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
// nx should fail if value exists // nx should fail if value exists
String statusSuccess = jedis.set(bfoo, binaryValue, bxx, bex, expireSeconds); String statusSuccess = jedis.set(bfoo, binaryValue, bxx, bex,
assertTrue(Keyword.OK.name().equalsIgnoreCase(statusSuccess)); expireSeconds);
assertTrue(Keyword.OK.name().equalsIgnoreCase(statusSuccess));
byte[] value = jedis.get(bfoo); byte[] value = jedis.get(bfoo);
assertTrue(Arrays.equals(binaryValue, value)); assertTrue(Arrays.equals(binaryValue, value));
assertNull(jedis.get(bbar)); assertNull(jedis.get(bbar));
} }
@Test @Test
public void setFailIfNotExistAndGet() { public void setFailIfNotExistAndGet() {
// xx should fail if value does NOT exists // xx should fail if value does NOT exists
String statusFail = jedis.set(bfoo, binaryValue, bxx, bex, expireSeconds); String statusFail = jedis.set(bfoo, binaryValue, bxx, bex,
assertNull(statusFail); expireSeconds);
assertNull(statusFail);
} }
@Test @Test
public void setAndExpireMillis() { public void setAndExpireMillis() {
String status = jedis.set(bfoo, binaryValue, bnx, bpx, expireMillis); String status = jedis.set(bfoo, binaryValue, bnx, bpx, expireMillis);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
long ttl = jedis.ttl(bfoo); long ttl = jedis.ttl(bfoo);
assertTrue(ttl > 0 && ttl <= expireSeconds); assertTrue(ttl > 0 && ttl <= expireSeconds);
} }
@Test @Test
public void setAndExpire() { public void setAndExpire() {
String status = jedis.set(bfoo, binaryValue, bnx, bex, expireSeconds); String status = jedis.set(bfoo, binaryValue, bnx, bex, expireSeconds);
assertTrue(Keyword.OK.name().equalsIgnoreCase(status)); assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
long ttl = jedis.ttl(bfoo); long ttl = jedis.ttl(bfoo);
assertTrue(ttl > 0 && ttl <= expireSeconds); assertTrue(ttl > 0 && ttl <= expireSeconds);
} }
@Test @Test
public void getSet() { public void getSet() {
byte[] value = jedis.getSet(bfoo, binaryValue); byte[] value = jedis.getSet(bfoo, binaryValue);
assertNull(value); assertNull(value);
value = jedis.get(bfoo); value = jedis.get(bfoo);
assertTrue(Arrays.equals(binaryValue, value)); assertTrue(Arrays.equals(binaryValue, value));
} }
@Test @Test
public void mget() { public void mget() {
List<byte[]> values = jedis.mget(bfoo, bbar); List<byte[]> values = jedis.mget(bfoo, bbar);
List<byte[]> expected = new ArrayList<byte[]>(); List<byte[]> expected = new ArrayList<byte[]>();
expected.add(null); expected.add(null);
expected.add(null); expected.add(null);
assertEquals(expected, values); assertEquals(expected, values);
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
expected = new ArrayList<byte[]>(); expected = new ArrayList<byte[]>();
expected.add(binaryValue); expected.add(binaryValue);
expected.add(null); expected.add(null);
values = jedis.mget(bfoo, bbar); values = jedis.mget(bfoo, bbar);
assertEquals(expected, values); assertEquals(expected, values);
jedis.set(bbar, bfoo); jedis.set(bbar, bfoo);
expected = new ArrayList<byte[]>(); expected = new ArrayList<byte[]>();
expected.add(binaryValue); expected.add(binaryValue);
expected.add(bfoo); expected.add(bfoo);
values = jedis.mget(bfoo, bbar); values = jedis.mget(bfoo, bbar);
assertEquals(expected, values); assertEquals(expected, values);
} }
@Test @Test
public void setnx() { public void setnx() {
long status = jedis.setnx(bfoo, binaryValue); long status = jedis.setnx(bfoo, binaryValue);
assertEquals(1, status); assertEquals(1, status);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
status = jedis.setnx(bfoo, bbar); status = jedis.setnx(bfoo, bbar);
assertEquals(0, status); assertEquals(0, status);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
} }
@Test @Test
public void setex() { public void setex() {
String status = jedis.setex(bfoo, 20, binaryValue); String status = jedis.setex(bfoo, 20, binaryValue);
assertEquals(Keyword.OK.name(), status); assertEquals(Keyword.OK.name(), status);
long ttl = jedis.ttl(bfoo); long ttl = jedis.ttl(bfoo);
assertTrue(ttl > 0 && ttl <= 20); assertTrue(ttl > 0 && ttl <= 20);
} }
@Test @Test
public void mset() { public void mset() {
String status = jedis.mset(bfoo, binaryValue, bbar, bfoo); String status = jedis.mset(bfoo, binaryValue, bbar, bfoo);
assertEquals(Keyword.OK.name(), status); assertEquals(Keyword.OK.name(), status);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
assertTrue(Arrays.equals(bfoo, jedis.get(bbar))); assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
} }
@Test @Test
public void msetnx() { public void msetnx() {
long status = jedis.msetnx(bfoo, binaryValue, bbar, bfoo); long status = jedis.msetnx(bfoo, binaryValue, bbar, bfoo);
assertEquals(1, status); assertEquals(1, status);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
assertTrue(Arrays.equals(bfoo, jedis.get(bbar))); assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
status = jedis.msetnx(bfoo, bbar, "bar2".getBytes(), "foo2".getBytes()); status = jedis.msetnx(bfoo, bbar, "bar2".getBytes(), "foo2".getBytes());
assertEquals(0, status); assertEquals(0, status);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
assertTrue(Arrays.equals(bfoo, jedis.get(bbar))); assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void incrWrongValue() { public void incrWrongValue() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
jedis.incr(bfoo); jedis.incr(bfoo);
} }
@Test @Test
public void incr() { public void incr() {
long value = jedis.incr(bfoo); long value = jedis.incr(bfoo);
assertEquals(1, value); assertEquals(1, value);
value = jedis.incr(bfoo); value = jedis.incr(bfoo);
assertEquals(2, value); assertEquals(2, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void incrByWrongValue() { public void incrByWrongValue() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
jedis.incrBy(bfoo, 2); jedis.incrBy(bfoo, 2);
} }
@Test @Test
public void incrBy() { public void incrBy() {
long value = jedis.incrBy(bfoo, 2); long value = jedis.incrBy(bfoo, 2);
assertEquals(2, value); assertEquals(2, value);
value = jedis.incrBy(bfoo, 2); value = jedis.incrBy(bfoo, 2);
assertEquals(4, value); assertEquals(4, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void decrWrongValue() { public void decrWrongValue() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
jedis.decr(bfoo); jedis.decr(bfoo);
} }
@Test @Test
public void decr() { public void decr() {
long value = jedis.decr(bfoo); long value = jedis.decr(bfoo);
assertEquals(-1, value); assertEquals(-1, value);
value = jedis.decr(bfoo); value = jedis.decr(bfoo);
assertEquals(-2, value); assertEquals(-2, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void decrByWrongValue() { public void decrByWrongValue() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
jedis.decrBy(bfoo, 2); jedis.decrBy(bfoo, 2);
} }
@Test @Test
public void decrBy() { public void decrBy() {
long value = jedis.decrBy(bfoo, 2); long value = jedis.decrBy(bfoo, 2);
assertEquals(-2, value); assertEquals(-2, value);
value = jedis.decrBy(bfoo, 2); value = jedis.decrBy(bfoo, 2);
assertEquals(-4, value); assertEquals(-4, value);
} }
@Test @Test
public void append() { public void append() {
byte[] first512 = new byte[512]; byte[] first512 = new byte[512];
System.arraycopy(binaryValue, 0, first512, 0, 512); System.arraycopy(binaryValue, 0, first512, 0, 512);
long value = jedis.append(bfoo, first512); long value = jedis.append(bfoo, first512);
assertEquals(512, value); assertEquals(512, value);
assertTrue(Arrays.equals(first512, jedis.get(bfoo))); assertTrue(Arrays.equals(first512, jedis.get(bfoo)));
byte[] rest = new byte[binaryValue.length - 512]; byte[] rest = new byte[binaryValue.length - 512];
System.arraycopy(binaryValue, 512, rest, 0, binaryValue.length - 512); System.arraycopy(binaryValue, 512, rest, 0, binaryValue.length - 512);
value = jedis.append(bfoo, rest); value = jedis.append(bfoo, rest);
assertEquals(binaryValue.length, value); assertEquals(binaryValue.length, value);
assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo))); assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
} }
@Test @Test
public void substr() { public void substr() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
byte[] first512 = new byte[512]; byte[] first512 = new byte[512];
System.arraycopy(binaryValue, 0, first512, 0, 512); System.arraycopy(binaryValue, 0, first512, 0, 512);
byte[] rfirst512 = jedis.substr(bfoo, 0, 511); byte[] rfirst512 = jedis.substr(bfoo, 0, 511);
assertTrue(Arrays.equals(first512, rfirst512)); assertTrue(Arrays.equals(first512, rfirst512));
byte[] last512 = new byte[512]; byte[] last512 = new byte[512];
System System.arraycopy(binaryValue, binaryValue.length - 512, last512, 0, 512);
.arraycopy(binaryValue, binaryValue.length - 512, last512, 0, assertTrue(Arrays.equals(last512, jedis.substr(bfoo, -512, -1)));
512);
assertTrue(Arrays.equals(last512, jedis.substr(bfoo, -512, -1)));
assertTrue(Arrays.equals(binaryValue, jedis.substr(bfoo, 0, -1))); assertTrue(Arrays.equals(binaryValue, jedis.substr(bfoo, 0, -1)));
assertTrue(Arrays.equals(last512, jedis.substr(bfoo, assertTrue(Arrays.equals(last512,
binaryValue.length - 512, 100000))); jedis.substr(bfoo, binaryValue.length - 512, 100000)));
} }
@Test @Test
public void strlen() { public void strlen() {
jedis.set(bfoo, binaryValue); jedis.set(bfoo, binaryValue);
assertEquals(binaryValue.length, jedis.strlen(bfoo).intValue()); assertEquals(binaryValue.length, jedis.strlen(bfoo).intValue());
} }
} }

102
src/test/java/redis/clients/jedis/tests/commands/BitCommandsTest.java
View File

@@ -7,87 +7,85 @@ import redis.clients.jedis.BitOP;
public class BitCommandsTest extends JedisCommandTestBase { public class BitCommandsTest extends JedisCommandTestBase {
@Test @Test
public void setAndgetbit() { public void setAndgetbit() {
boolean bit = jedis.setbit("foo", 0, true); boolean bit = jedis.setbit("foo", 0, true);
assertEquals(false, bit); assertEquals(false, bit);
bit = jedis.getbit("foo", 0); bit = jedis.getbit("foo", 0);
assertEquals(true, bit); assertEquals(true, bit);
boolean bbit = jedis.setbit("bfoo".getBytes(), 0, "1".getBytes()); boolean bbit = jedis.setbit("bfoo".getBytes(), 0, "1".getBytes());
assertFalse(bbit); assertFalse(bbit);
bbit = jedis.getbit("bfoo".getBytes(), 0); bbit = jedis.getbit("bfoo".getBytes(), 0);
assertTrue(bbit); assertTrue(bbit);
} }
@Test @Test
public void setAndgetrange() { public void setAndgetrange() {
jedis.set("key1", "Hello World"); jedis.set("key1", "Hello World");
long reply = jedis.setrange("key1", 6, "Jedis"); long reply = jedis.setrange("key1", 6, "Jedis");
assertEquals(11, reply); assertEquals(11, reply);
assertEquals(jedis.get("key1"), "Hello Jedis"); assertEquals(jedis.get("key1"), "Hello Jedis");
assertEquals("Hello", jedis.getrange("key1", 0, 4)); assertEquals("Hello", jedis.getrange("key1", 0, 4));
assertEquals("Jedis", jedis.getrange("key1", 6, 11)); assertEquals("Jedis", jedis.getrange("key1", 6, 11));
} }
@Test @Test
public void bitCount() { public void bitCount() {
jedis.del("foo"); jedis.del("foo");
jedis.setbit("foo", 16, true); jedis.setbit("foo", 16, true);
jedis.setbit("foo", 24, true); jedis.setbit("foo", 24, true);
jedis.setbit("foo", 40, true); jedis.setbit("foo", 40, true);
jedis.setbit("foo", 56, true); jedis.setbit("foo", 56, true);
long c4 = jedis.bitcount("foo"); long c4 = jedis.bitcount("foo");
assertEquals(4, c4); assertEquals(4, c4);
long c3 = jedis.bitcount("foo", 2L, 5L); long c3 = jedis.bitcount("foo", 2L, 5L);
assertEquals(3, c3); assertEquals(3, c3);
jedis.del("foo"); jedis.del("foo");
} }
@Test @Test
public void bitOp() public void bitOp() {
{ jedis.set("key1", "\u0060");
jedis.set("key1", "\u0060"); jedis.set("key2", "\u0044");
jedis.set("key2", "\u0044");
jedis.bitop(BitOP.AND, "resultAnd", "key1", "key2"); jedis.bitop(BitOP.AND, "resultAnd", "key1", "key2");
String resultAnd = jedis.get("resultAnd"); String resultAnd = jedis.get("resultAnd");
assertEquals("\u0040", resultAnd); assertEquals("\u0040", resultAnd);
jedis.bitop(BitOP.OR, "resultOr", "key1", "key2"); jedis.bitop(BitOP.OR, "resultOr", "key1", "key2");
String resultOr = jedis.get("resultOr"); String resultOr = jedis.get("resultOr");
assertEquals("\u0064", resultOr); assertEquals("\u0064", resultOr);
jedis.bitop(BitOP.XOR, "resultXor", "key1", "key2"); jedis.bitop(BitOP.XOR, "resultXor", "key1", "key2");
String resultXor = jedis.get("resultXor"); String resultXor = jedis.get("resultXor");
assertEquals("\u0024", resultXor); assertEquals("\u0024", resultXor);
jedis.del("resultAnd"); jedis.del("resultAnd");
jedis.del("resultOr"); jedis.del("resultOr");
jedis.del("resultXor"); jedis.del("resultXor");
jedis.del("key1"); jedis.del("key1");
jedis.del("key2"); jedis.del("key2");
} }
@Test @Test
public void bitOpNot() public void bitOpNot() {
{ jedis.del("key");
jedis.del("key"); jedis.setbit("key", 0, true);
jedis.setbit("key", 0, true); jedis.setbit("key", 4, true);
jedis.setbit("key", 4, true);
jedis.bitop(BitOP.NOT, "resultNot", "key"); jedis.bitop(BitOP.NOT, "resultNot", "key");
String resultNot = jedis.get("resultNot"); String resultNot = jedis.get("resultNot");
assertEquals("\u0077", resultNot); assertEquals("\u0077", resultNot);
jedis.del("key"); jedis.del("key");
jedis.del("resultNot"); jedis.del("resultNot");
} }
} }

57
src/test/java/redis/clients/jedis/tests/commands/ClusterCommandsTest.java
View File

@@ -37,42 +37,45 @@ public class ClusterCommandsTest extends JedisTestBase {
node1.disconnect(); node1.disconnect();
node2.disconnect(); node2.disconnect();
} }
@AfterClass @AfterClass
public static void removeSlots() throws InterruptedException { public static void removeSlots() throws InterruptedException {
//This is to wait for gossip to replicate data. // This is to wait for gossip to replicate data.
waitForEqualClusterSize(); waitForEqualClusterSize();
String[] nodes = node1.clusterNodes().split("\n"); String[] nodes = node1.clusterNodes().split("\n");
String node1Id = nodes[0].split(" ")[0]; String node1Id = nodes[0].split(" ")[0];
node1.clusterDelSlots(1,2,3,4,5,500); node1.clusterDelSlots(1, 2, 3, 4, 5, 500);
node1.clusterSetSlotNode(5000, node1Id); node1.clusterSetSlotNode(5000, node1Id);
node1.clusterDelSlots(5000, 10000); node1.clusterDelSlots(5000, 10000);
node1.clusterDelSlots(6000); node1.clusterDelSlots(6000);
node2.clusterDelSlots(6000,1,2,3,4,5,500,5000); node2.clusterDelSlots(6000, 1, 2, 3, 4, 5, 500, 5000);
try { try {
node2.clusterDelSlots(10000); node2.clusterDelSlots(10000);
} catch (JedisDataException jde) { } catch (JedisDataException jde) {
//Do nothing, slot may or may not be assigned depending on gossip // Do nothing, slot may or may not be assigned depending on gossip
} }
} }
private static void waitForEqualClusterSize() throws InterruptedException { private static void waitForEqualClusterSize() throws InterruptedException {
boolean notEqualSize = true; boolean notEqualSize = true;
while (notEqualSize) { while (notEqualSize) {
notEqualSize = getClusterAttribute(node1.clusterInfo(), "cluster_known_nodes") == getClusterAttribute(node2.clusterInfo(), "cluster_size") ? false : true; notEqualSize = getClusterAttribute(node1.clusterInfo(),
} "cluster_known_nodes") == getClusterAttribute(
node2.clusterInfo(), "cluster_size") ? false : true;
} }
}
private static int getClusterAttribute(String clusterInfo, String attributeName) { private static int getClusterAttribute(String clusterInfo,
for (String infoElement: clusterInfo.split("\n")) { String attributeName) {
if (infoElement.contains(attributeName)) { for (String infoElement : clusterInfo.split("\n")) {
return Integer.valueOf(infoElement.split(":")[1].trim()); if (infoElement.contains(attributeName)) {
} return Integer.valueOf(infoElement.split(":")[1].trim());
} }
return 0;
} }
return 0;
}
@Test @Test
public void clusterNodes() { public void clusterNodes() {
String nodes = node1.clusterNodes(); String nodes = node1.clusterNodes();
assertTrue(nodes.split("\n").length > 0); assertTrue(nodes.split("\n").length > 0);

6
src/test/java/redis/clients/jedis/tests/commands/ConnectionHandlingCommandsTest.java
View File

@@ -11,12 +11,12 @@ public class ConnectionHandlingCommandsTest extends JedisCommandTestBase {
@Test @Test
public void quit() { public void quit() {
assertEquals("OK", jedis.quit()); assertEquals("OK", jedis.quit());
} }
@Test @Test
public void binary_quit() { public void binary_quit() {
BinaryJedis bj = new BinaryJedis(hnp.getHost()); BinaryJedis bj = new BinaryJedis(hnp.getHost());
assertEquals("OK", bj.quit()); assertEquals("OK", bj.quit());
} }
} }

9
src/test/java/redis/clients/jedis/tests/commands/ControlCommandsTest.java
View File

@@ -61,6 +61,11 @@ public class ControlCommandsTest extends JedisCommandTestBase {
public void monitor() { public void monitor() {
new Thread(new Runnable() { new Thread(new Runnable() {
public void run() { public void run() {
try {
// sleep 100ms to make sure that monitor thread runs first
Thread.sleep(100);
} catch (InterruptedException e) {
}
Jedis j = new Jedis("localhost"); Jedis j = new Jedis("localhost");
j.auth("foobared"); j.auth("foobared");
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
@@ -112,10 +117,10 @@ public class ControlCommandsTest extends JedisCommandTestBase {
resp = jedis.debug(DebugParams.RELOAD()); resp = jedis.debug(DebugParams.RELOAD());
assertNotNull(resp); assertNotNull(resp);
} }
@Test @Test
public void waitReplicas() { public void waitReplicas() {
Long replicas = jedis.waitReplicas(1, 100); Long replicas = jedis.waitReplicas(1, 100);
assertEquals(1, replicas.longValue()); assertEquals(1, replicas.longValue());
} }
} }

6
src/test/java/redis/clients/jedis/tests/commands/HashesCommandsTest.java
View File

@@ -309,7 +309,8 @@ public class HashesCommandsTest extends JedisCommandTestBase {
jedis.hset("foo", "b", "b"); jedis.hset("foo", "b", "b");
jedis.hset("foo", "a", "a"); jedis.hset("foo", "a", "a");
jedis.hset("foo", "aa", "aa"); jedis.hset("foo", "aa", "aa");
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params); ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0,
params);
assertEquals(0, result.getCursor()); assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty()); assertFalse(result.getResult().isEmpty());
@@ -324,7 +325,8 @@ public class HashesCommandsTest extends JedisCommandTestBase {
jedis.hset("foo", "a" + i, "a" + i); jedis.hset("foo", "a" + i, "a" + i);
} }
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params); ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0,
params);
assertFalse(result.getResult().isEmpty()); assertFalse(result.getResult().isEmpty());
} }

94
src/test/java/redis/clients/jedis/tests/commands/JedisCommandTestBase.java
View File

@@ -20,77 +20,77 @@ public abstract class JedisCommandTestBase extends JedisTestBase {
protected Jedis jedis; protected Jedis jedis;
public JedisCommandTestBase() { public JedisCommandTestBase() {
super(); super();
} }
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
jedis = new Jedis(hnp.getHost(), hnp.getPort(), 500); jedis = new Jedis(hnp.getHost(), hnp.getPort(), 500);
jedis.connect(); jedis.connect();
jedis.auth("foobared"); jedis.auth("foobared");
jedis.configSet("timeout", "300"); jedis.configSet("timeout", "300");
jedis.flushAll(); jedis.flushAll();
} }
@After @After
public void tearDown() { public void tearDown() {
jedis.disconnect(); jedis.disconnect();
} }
protected Jedis createJedis() { protected Jedis createJedis() {
Jedis j = new Jedis(hnp.getHost(), hnp.getPort()); Jedis j = new Jedis(hnp.getHost(), hnp.getPort());
j.connect(); j.connect();
j.auth("foobared"); j.auth("foobared");
j.flushAll(); j.flushAll();
return j; return j;
} }
protected void assertEquals(List<byte[]> expected, List<byte[]> actual) { protected void assertEquals(List<byte[]> expected, List<byte[]> actual) {
assertEquals(expected.size(), actual.size()); assertEquals(expected.size(), actual.size());
for (int n = 0; n < expected.size(); n++) { for (int n = 0; n < expected.size(); n++) {
assertArrayEquals(expected.get(n), actual.get(n)); assertArrayEquals(expected.get(n), actual.get(n));
} }
} }
protected void assertEquals(Set<byte[]> expected, Set<byte[]> actual) { protected void assertEquals(Set<byte[]> expected, Set<byte[]> actual) {
assertEquals(expected.size(), actual.size()); assertEquals(expected.size(), actual.size());
Iterator<byte[]> e = expected.iterator(); Iterator<byte[]> e = expected.iterator();
while (e.hasNext()) { while (e.hasNext()) {
byte[] next = e.next(); byte[] next = e.next();
boolean contained = false; boolean contained = false;
for (byte[] element : expected) { for (byte[] element : expected) {
if (Arrays.equals(next, element)) { if (Arrays.equals(next, element)) {
contained = true; contained = true;
} }
} }
if (!contained) { if (!contained) {
throw new ComparisonFailure("element is missing", throw new ComparisonFailure("element is missing",
Arrays.toString(next), actual.toString()); Arrays.toString(next), actual.toString());
} }
} }
} }
protected boolean arrayContains(List<byte[]> array, byte[] expected) { protected boolean arrayContains(List<byte[]> array, byte[] expected) {
for (byte[] a : array) { for (byte[] a : array) {
try { try {
assertArrayEquals(a, expected); assertArrayEquals(a, expected);
return true; return true;
} catch (AssertionError e) { } catch (AssertionError e) {
} }
} }
return false; return false;
} }
protected boolean setContains(Set<byte[]> set, byte[] expected) { protected boolean setContains(Set<byte[]> set, byte[] expected) {
for (byte[] a : set) { for (byte[] a : set) {
try { try {
assertArrayEquals(a, expected); assertArrayEquals(a, expected);
return true; return true;
} catch (AssertionError e) { } catch (AssertionError e) {
} }
} }
return false; return false;
} }
} }

748
src/test/java/redis/clients/jedis/tests/commands/ListCommandsTest.java
View File

@@ -26,561 +26,559 @@ public class ListCommandsTest extends JedisCommandTestBase {
@Test @Test
public void rpush() { public void rpush() {
long size = jedis.rpush("foo", "bar"); long size = jedis.rpush("foo", "bar");
assertEquals(1, size); assertEquals(1, size);
size = jedis.rpush("foo", "foo"); size = jedis.rpush("foo", "foo");
assertEquals(2, size); assertEquals(2, size);
size = jedis.rpush("foo", "bar", "foo"); size = jedis.rpush("foo", "bar", "foo");
assertEquals(4, size); assertEquals(4, size);
// Binary // Binary
long bsize = jedis.rpush(bfoo, bbar); long bsize = jedis.rpush(bfoo, bbar);
assertEquals(1, bsize); assertEquals(1, bsize);
bsize = jedis.rpush(bfoo, bfoo); bsize = jedis.rpush(bfoo, bfoo);
assertEquals(2, bsize); assertEquals(2, bsize);
bsize = jedis.rpush(bfoo, bbar, bfoo); bsize = jedis.rpush(bfoo, bbar, bfoo);
assertEquals(4, bsize); assertEquals(4, bsize);
} }
@Test @Test
public void lpush() { public void lpush() {
long size = jedis.lpush("foo", "bar"); long size = jedis.lpush("foo", "bar");
assertEquals(1, size); assertEquals(1, size);
size = jedis.lpush("foo", "foo"); size = jedis.lpush("foo", "foo");
assertEquals(2, size); assertEquals(2, size);
size = jedis.lpush("foo", "bar", "foo"); size = jedis.lpush("foo", "bar", "foo");
assertEquals(4, size); assertEquals(4, size);
// Binary // Binary
long bsize = jedis.lpush(bfoo, bbar); long bsize = jedis.lpush(bfoo, bbar);
assertEquals(1, bsize); assertEquals(1, bsize);
bsize = jedis.lpush(bfoo, bfoo); bsize = jedis.lpush(bfoo, bfoo);
assertEquals(2, bsize); assertEquals(2, bsize);
bsize = jedis.lpush(bfoo, bbar, bfoo); bsize = jedis.lpush(bfoo, bbar, bfoo);
assertEquals(4, bsize); assertEquals(4, bsize);
} }
@Test @Test
public void llen() { public void llen() {
assertEquals(0, jedis.llen("foo").intValue()); assertEquals(0, jedis.llen("foo").intValue());
jedis.lpush("foo", "bar"); jedis.lpush("foo", "bar");
jedis.lpush("foo", "car"); jedis.lpush("foo", "car");
assertEquals(2, jedis.llen("foo").intValue()); assertEquals(2, jedis.llen("foo").intValue());
// Binary // Binary
assertEquals(0, jedis.llen(bfoo).intValue()); assertEquals(0, jedis.llen(bfoo).intValue());
jedis.lpush(bfoo, bbar); jedis.lpush(bfoo, bbar);
jedis.lpush(bfoo, bcar); jedis.lpush(bfoo, bcar);
assertEquals(2, jedis.llen(bfoo).intValue()); assertEquals(2, jedis.llen(bfoo).intValue());
} }
@Test @Test
public void llenNotOnList() { public void llenNotOnList() {
try { try {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.llen("foo"); jedis.llen("foo");
fail("JedisDataException expected"); fail("JedisDataException expected");
} catch (final JedisDataException e) { } catch (final JedisDataException e) {
} }
// Binary // Binary
try { try {
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
jedis.llen(bfoo); jedis.llen(bfoo);
fail("JedisDataException expected"); fail("JedisDataException expected");
} catch (final JedisDataException e) { } catch (final JedisDataException e) {
} }
} }
@Test @Test
public void lrange() { public void lrange() {
jedis.rpush("foo", "a"); jedis.rpush("foo", "a");
jedis.rpush("foo", "b"); jedis.rpush("foo", "b");
jedis.rpush("foo", "c"); jedis.rpush("foo", "c");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
List<String> range = jedis.lrange("foo", 0, 2); List<String> range = jedis.lrange("foo", 0, 2);
assertEquals(expected, range); assertEquals(expected, range);
range = jedis.lrange("foo", 0, 20); range = jedis.lrange("foo", 0, 20);
assertEquals(expected, range); assertEquals(expected, range);
expected = new ArrayList<String>(); expected = new ArrayList<String>();
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
range = jedis.lrange("foo", 1, 2); range = jedis.lrange("foo", 1, 2);
assertEquals(expected, range); assertEquals(expected, range);
expected = new ArrayList<String>(); expected = new ArrayList<String>();
range = jedis.lrange("foo", 2, 1); range = jedis.lrange("foo", 2, 1);
assertEquals(expected, range); assertEquals(expected, range);
// Binary // Binary
jedis.rpush(bfoo, bA); jedis.rpush(bfoo, bA);
jedis.rpush(bfoo, bB); jedis.rpush(bfoo, bB);
jedis.rpush(bfoo, bC); jedis.rpush(bfoo, bC);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bA); bexpected.add(bA);
bexpected.add(bB); bexpected.add(bB);
bexpected.add(bC); bexpected.add(bC);
List<byte[]> brange = jedis.lrange(bfoo, 0, 2); List<byte[]> brange = jedis.lrange(bfoo, 0, 2);
assertEquals(bexpected, brange); assertEquals(bexpected, brange);
brange = jedis.lrange(bfoo, 0, 20); brange = jedis.lrange(bfoo, 0, 20);
assertEquals(bexpected, brange); assertEquals(bexpected, brange);
bexpected = new ArrayList<byte[]>(); bexpected = new ArrayList<byte[]>();
bexpected.add(bB); bexpected.add(bB);
bexpected.add(bC); bexpected.add(bC);
brange = jedis.lrange(bfoo, 1, 2); brange = jedis.lrange(bfoo, 1, 2);
assertEquals(bexpected, brange); assertEquals(bexpected, brange);
bexpected = new ArrayList<byte[]>(); bexpected = new ArrayList<byte[]>();
brange = jedis.lrange(bfoo, 2, 1); brange = jedis.lrange(bfoo, 2, 1);
assertEquals(bexpected, brange); assertEquals(bexpected, brange);
} }
@Test @Test
public void ltrim() { public void ltrim() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
String status = jedis.ltrim("foo", 0, 1); String status = jedis.ltrim("foo", 0, 1);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("3"); expected.add("3");
expected.add("2"); expected.add("2");
assertEquals("OK", status); assertEquals("OK", status);
assertEquals(2, jedis.llen("foo").intValue()); assertEquals(2, jedis.llen("foo").intValue());
assertEquals(expected, jedis.lrange("foo", 0, 100)); assertEquals(expected, jedis.lrange("foo", 0, 100));
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
String bstatus = jedis.ltrim(bfoo, 0, 1); String bstatus = jedis.ltrim(bfoo, 0, 1);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b3); bexpected.add(b3);
bexpected.add(b2); bexpected.add(b2);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertEquals(2, jedis.llen(bfoo).intValue()); assertEquals(2, jedis.llen(bfoo).intValue());
assertEquals(bexpected, jedis.lrange(bfoo, 0, 100)); assertEquals(bexpected, jedis.lrange(bfoo, 0, 100));
} }
@Test @Test
public void lindex() { public void lindex() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("3"); expected.add("3");
expected.add("bar"); expected.add("bar");
expected.add("1"); expected.add("1");
String status = jedis.lset("foo", 1, "bar"); String status = jedis.lset("foo", 1, "bar");
assertEquals("OK", status); assertEquals("OK", status);
assertEquals(expected, jedis.lrange("foo", 0, 100)); assertEquals(expected, jedis.lrange("foo", 0, 100));
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b3); bexpected.add(b3);
bexpected.add(bbar); bexpected.add(bbar);
bexpected.add(b1); bexpected.add(b1);
String bstatus = jedis.lset(bfoo, 1, bbar); String bstatus = jedis.lset(bfoo, 1, bbar);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertEquals(bexpected, jedis.lrange(bfoo, 0, 100)); assertEquals(bexpected, jedis.lrange(bfoo, 0, 100));
} }
@Test @Test
public void lset() { public void lset() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
assertEquals("3", jedis.lindex("foo", 0)); assertEquals("3", jedis.lindex("foo", 0));
assertEquals(null, jedis.lindex("foo", 100)); assertEquals(null, jedis.lindex("foo", 100));
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
assertArrayEquals(b3, jedis.lindex(bfoo, 0)); assertArrayEquals(b3, jedis.lindex(bfoo, 0));
assertEquals(null, jedis.lindex(bfoo, 100)); assertEquals(null, jedis.lindex(bfoo, 100));
} }
@Test @Test
public void lrem() { public void lrem() {
jedis.lpush("foo", "hello"); jedis.lpush("foo", "hello");
jedis.lpush("foo", "hello"); jedis.lpush("foo", "hello");
jedis.lpush("foo", "x"); jedis.lpush("foo", "x");
jedis.lpush("foo", "hello"); jedis.lpush("foo", "hello");
jedis.lpush("foo", "c"); jedis.lpush("foo", "c");
jedis.lpush("foo", "b"); jedis.lpush("foo", "b");
jedis.lpush("foo", "a"); jedis.lpush("foo", "a");
long count = jedis.lrem("foo", -2, "hello"); long count = jedis.lrem("foo", -2, "hello");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
expected.add("hello"); expected.add("hello");
expected.add("x"); expected.add("x");
assertEquals(2, count); assertEquals(2, count);
assertEquals(expected, jedis.lrange("foo", 0, 1000)); assertEquals(expected, jedis.lrange("foo", 0, 1000));
assertEquals(0, jedis.lrem("bar", 100, "foo").intValue()); assertEquals(0, jedis.lrem("bar", 100, "foo").intValue());
// Binary // Binary
jedis.lpush(bfoo, bhello); jedis.lpush(bfoo, bhello);
jedis.lpush(bfoo, bhello); jedis.lpush(bfoo, bhello);
jedis.lpush(bfoo, bx); jedis.lpush(bfoo, bx);
jedis.lpush(bfoo, bhello); jedis.lpush(bfoo, bhello);
jedis.lpush(bfoo, bC); jedis.lpush(bfoo, bC);
jedis.lpush(bfoo, bB); jedis.lpush(bfoo, bB);
jedis.lpush(bfoo, bA); jedis.lpush(bfoo, bA);
long bcount = jedis.lrem(bfoo, -2, bhello); long bcount = jedis.lrem(bfoo, -2, bhello);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bA); bexpected.add(bA);
bexpected.add(bB); bexpected.add(bB);
bexpected.add(bC); bexpected.add(bC);
bexpected.add(bhello); bexpected.add(bhello);
bexpected.add(bx); bexpected.add(bx);
assertEquals(2, bcount); assertEquals(2, bcount);
assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000)); assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000));
assertEquals(0, jedis.lrem(bbar, 100, bfoo).intValue()); assertEquals(0, jedis.lrem(bbar, 100, bfoo).intValue());
} }
@Test @Test
public void lpop() { public void lpop() {
jedis.rpush("foo", "a"); jedis.rpush("foo", "a");
jedis.rpush("foo", "b"); jedis.rpush("foo", "b");
jedis.rpush("foo", "c"); jedis.rpush("foo", "c");
String element = jedis.lpop("foo"); String element = jedis.lpop("foo");
assertEquals("a", element); assertEquals("a", element);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
assertEquals(expected, jedis.lrange("foo", 0, 1000)); assertEquals(expected, jedis.lrange("foo", 0, 1000));
jedis.lpop("foo"); jedis.lpop("foo");
jedis.lpop("foo"); jedis.lpop("foo");
element = jedis.lpop("foo"); element = jedis.lpop("foo");
assertEquals(null, element); assertEquals(null, element);
// Binary // Binary
jedis.rpush(bfoo, bA); jedis.rpush(bfoo, bA);
jedis.rpush(bfoo, bB); jedis.rpush(bfoo, bB);
jedis.rpush(bfoo, bC); jedis.rpush(bfoo, bC);
byte[] belement = jedis.lpop(bfoo); byte[] belement = jedis.lpop(bfoo);
assertArrayEquals(bA, belement); assertArrayEquals(bA, belement);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bB); bexpected.add(bB);
bexpected.add(bC); bexpected.add(bC);
assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000)); assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000));
jedis.lpop(bfoo); jedis.lpop(bfoo);
jedis.lpop(bfoo); jedis.lpop(bfoo);
belement = jedis.lpop(bfoo); belement = jedis.lpop(bfoo);
assertEquals(null, belement); assertEquals(null, belement);
} }
@Test @Test
public void rpop() { public void rpop() {
jedis.rpush("foo", "a"); jedis.rpush("foo", "a");
jedis.rpush("foo", "b"); jedis.rpush("foo", "b");
jedis.rpush("foo", "c"); jedis.rpush("foo", "c");
String element = jedis.rpop("foo"); String element = jedis.rpop("foo");
assertEquals("c", element); assertEquals("c", element);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
assertEquals(expected, jedis.lrange("foo", 0, 1000)); assertEquals(expected, jedis.lrange("foo", 0, 1000));
jedis.rpop("foo"); jedis.rpop("foo");
jedis.rpop("foo"); jedis.rpop("foo");
element = jedis.rpop("foo"); element = jedis.rpop("foo");
assertEquals(null, element); assertEquals(null, element);
// Binary // Binary
jedis.rpush(bfoo, bA); jedis.rpush(bfoo, bA);
jedis.rpush(bfoo, bB); jedis.rpush(bfoo, bB);
jedis.rpush(bfoo, bC); jedis.rpush(bfoo, bC);
byte[] belement = jedis.rpop(bfoo); byte[] belement = jedis.rpop(bfoo);
assertArrayEquals(bC, belement); assertArrayEquals(bC, belement);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bA); bexpected.add(bA);
bexpected.add(bB); bexpected.add(bB);
assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000)); assertEquals(bexpected, jedis.lrange(bfoo, 0, 1000));
jedis.rpop(bfoo); jedis.rpop(bfoo);
jedis.rpop(bfoo); jedis.rpop(bfoo);
belement = jedis.rpop(bfoo); belement = jedis.rpop(bfoo);
assertEquals(null, belement); assertEquals(null, belement);
} }
@Test @Test
public void rpoplpush() { public void rpoplpush() {
jedis.rpush("foo", "a"); jedis.rpush("foo", "a");
jedis.rpush("foo", "b"); jedis.rpush("foo", "b");
jedis.rpush("foo", "c"); jedis.rpush("foo", "c");
jedis.rpush("dst", "foo"); jedis.rpush("dst", "foo");
jedis.rpush("dst", "bar"); jedis.rpush("dst", "bar");
String element = jedis.rpoplpush("foo", "dst"); String element = jedis.rpoplpush("foo", "dst");
assertEquals("c", element); assertEquals("c", element);
List<String> srcExpected = new ArrayList<String>(); List<String> srcExpected = new ArrayList<String>();
srcExpected.add("a"); srcExpected.add("a");
srcExpected.add("b"); srcExpected.add("b");
List<String> dstExpected = new ArrayList<String>(); List<String> dstExpected = new ArrayList<String>();
dstExpected.add("c"); dstExpected.add("c");
dstExpected.add("foo"); dstExpected.add("foo");
dstExpected.add("bar"); dstExpected.add("bar");
assertEquals(srcExpected, jedis.lrange("foo", 0, 1000)); assertEquals(srcExpected, jedis.lrange("foo", 0, 1000));
assertEquals(dstExpected, jedis.lrange("dst", 0, 1000)); assertEquals(dstExpected, jedis.lrange("dst", 0, 1000));
// Binary // Binary
jedis.rpush(bfoo, bA); jedis.rpush(bfoo, bA);
jedis.rpush(bfoo, bB); jedis.rpush(bfoo, bB);
jedis.rpush(bfoo, bC); jedis.rpush(bfoo, bC);
jedis.rpush(bdst, bfoo); jedis.rpush(bdst, bfoo);
jedis.rpush(bdst, bbar); jedis.rpush(bdst, bbar);
byte[] belement = jedis.rpoplpush(bfoo, bdst); byte[] belement = jedis.rpoplpush(bfoo, bdst);
assertArrayEquals(bC, belement); assertArrayEquals(bC, belement);
List<byte[]> bsrcExpected = new ArrayList<byte[]>(); List<byte[]> bsrcExpected = new ArrayList<byte[]>();
bsrcExpected.add(bA); bsrcExpected.add(bA);
bsrcExpected.add(bB); bsrcExpected.add(bB);
List<byte[]> bdstExpected = new ArrayList<byte[]>(); List<byte[]> bdstExpected = new ArrayList<byte[]>();
bdstExpected.add(bC); bdstExpected.add(bC);
bdstExpected.add(bfoo); bdstExpected.add(bfoo);
bdstExpected.add(bbar); bdstExpected.add(bbar);
assertEquals(bsrcExpected, jedis.lrange(bfoo, 0, 1000)); assertEquals(bsrcExpected, jedis.lrange(bfoo, 0, 1000));
assertEquals(bdstExpected, jedis.lrange(bdst, 0, 1000)); assertEquals(bdstExpected, jedis.lrange(bdst, 0, 1000));
} }
@Test @Test
public void blpop() throws InterruptedException { public void blpop() throws InterruptedException {
List<String> result = jedis.blpop(1, "foo"); List<String> result = jedis.blpop(1, "foo");
assertNull(result); assertNull(result);
jedis.lpush("foo", "bar"); jedis.lpush("foo", "bar");
result = jedis.blpop(1, "foo"); result = jedis.blpop(1, "foo");
assertNotNull(result); assertNotNull(result);
assertEquals(2, result.size()); assertEquals(2, result.size());
assertEquals("foo", result.get(0)); assertEquals("foo", result.get(0));
assertEquals("bar", result.get(1)); assertEquals("bar", result.get(1));
// Binary // Binary
jedis.lpush(bfoo, bbar); jedis.lpush(bfoo, bbar);
List<byte[]> bresult = jedis.blpop(1, bfoo); List<byte[]> bresult = jedis.blpop(1, bfoo);
assertNotNull(bresult); assertNotNull(bresult);
assertEquals(2, bresult.size()); assertEquals(2, bresult.size());
assertArrayEquals(bfoo, bresult.get(0)); assertArrayEquals(bfoo, bresult.get(0));
assertArrayEquals(bbar, bresult.get(1)); assertArrayEquals(bbar, bresult.get(1));
} }
@Test @Test
public void brpop() throws InterruptedException { public void brpop() throws InterruptedException {
List<String> result = jedis.brpop(1, "foo"); List<String> result = jedis.brpop(1, "foo");
assertNull(result); assertNull(result);
jedis.lpush("foo", "bar");
result = jedis.brpop(1, "foo");
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("foo", result.get(0));
assertEquals("bar", result.get(1));
jedis.lpush("foo", "bar"); // Binary
result = jedis.brpop(1, "foo");
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("foo", result.get(0));
assertEquals("bar", result.get(1));
// Binary jedis.lpush(bfoo, bbar);
List<byte[]> bresult = jedis.brpop(1, bfoo);
jedis.lpush(bfoo, bbar); assertNotNull(bresult);
List<byte[]> bresult = jedis.brpop(1, bfoo); assertEquals(2, bresult.size());
assertNotNull(bresult); assertArrayEquals(bfoo, bresult.get(0));
assertEquals(2, bresult.size()); assertArrayEquals(bbar, bresult.get(1));
assertArrayEquals(bfoo, bresult.get(0));
assertArrayEquals(bbar, bresult.get(1));
} }
@Test @Test
public void lpushx() { public void lpushx() {
long status = jedis.lpushx("foo", "bar"); long status = jedis.lpushx("foo", "bar");
assertEquals(0, status); assertEquals(0, status);
jedis.lpush("foo", "a"); jedis.lpush("foo", "a");
status = jedis.lpushx("foo", "b"); status = jedis.lpushx("foo", "b");
assertEquals(2, status); assertEquals(2, status);
// Binary // Binary
long bstatus = jedis.lpushx(bfoo, bbar); long bstatus = jedis.lpushx(bfoo, bbar);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.lpush(bfoo, bA); jedis.lpush(bfoo, bA);
bstatus = jedis.lpushx(bfoo, bB); bstatus = jedis.lpushx(bfoo, bB);
assertEquals(2, bstatus); assertEquals(2, bstatus);
} }
@Test @Test
public void rpushx() { public void rpushx() {
long status = jedis.rpushx("foo", "bar"); long status = jedis.rpushx("foo", "bar");
assertEquals(0, status); assertEquals(0, status);
jedis.lpush("foo", "a"); jedis.lpush("foo", "a");
status = jedis.rpushx("foo", "b"); status = jedis.rpushx("foo", "b");
assertEquals(2, status); assertEquals(2, status);
// Binary // Binary
long bstatus = jedis.rpushx(bfoo, bbar); long bstatus = jedis.rpushx(bfoo, bbar);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.lpush(bfoo, bA); jedis.lpush(bfoo, bA);
bstatus = jedis.rpushx(bfoo, bB); bstatus = jedis.rpushx(bfoo, bB);
assertEquals(2, bstatus); assertEquals(2, bstatus);
} }
@Test @Test
public void linsert() { public void linsert() {
long status = jedis.linsert("foo", Client.LIST_POSITION.BEFORE, "bar", long status = jedis.linsert("foo", Client.LIST_POSITION.BEFORE, "bar",
"car"); "car");
assertEquals(0, status); assertEquals(0, status);
jedis.lpush("foo", "a"); jedis.lpush("foo", "a");
status = jedis.linsert("foo", Client.LIST_POSITION.AFTER, "a", "b"); status = jedis.linsert("foo", Client.LIST_POSITION.AFTER, "a", "b");
assertEquals(2, status); assertEquals(2, status);
List<String> actual = jedis.lrange("foo", 0, 100); List<String> actual = jedis.lrange("foo", 0, 100);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
assertEquals(expected, actual); assertEquals(expected, actual);
status = jedis status = jedis
.linsert("foo", Client.LIST_POSITION.BEFORE, "bar", "car"); .linsert("foo", Client.LIST_POSITION.BEFORE, "bar", "car");
assertEquals(-1, status); assertEquals(-1, status);
// Binary // Binary
long bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar, long bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar,
bcar); bcar);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.lpush(bfoo, bA); jedis.lpush(bfoo, bA);
bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.AFTER, bA, bB); bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.AFTER, bA, bB);
assertEquals(2, bstatus); assertEquals(2, bstatus);
List<byte[]> bactual = jedis.lrange(bfoo, 0, 100); List<byte[]> bactual = jedis.lrange(bfoo, 0, 100);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bA); bexpected.add(bA);
bexpected.add(bB); bexpected.add(bB);
assertEquals(bexpected, bactual); assertEquals(bexpected, bactual);
bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar, bcar); bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar, bcar);
assertEquals(-1, bstatus); assertEquals(-1, bstatus);
} }
@Test @Test
public void brpoplpush() { public void brpoplpush() {
(new Thread(new Runnable() { (new Thread(new Runnable() {
public void run() { public void run() {
try { try {
Thread.sleep(100); Thread.sleep(100);
Jedis j = createJedis(); Jedis j = createJedis();
j.lpush("foo", "a"); j.lpush("foo", "a");
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
})).start(); })).start();
String element = jedis.brpoplpush("foo", "bar", 0); String element = jedis.brpoplpush("foo", "bar", 0);
assertEquals("a", element); assertEquals("a", element);
assertEquals(1, jedis.llen("bar").longValue()); assertEquals(1, jedis.llen("bar").longValue());
assertEquals("a", jedis.lrange("bar", 0, -1).get(0)); assertEquals("a", jedis.lrange("bar", 0, -1).get(0));
(new Thread(new Runnable() { (new Thread(new Runnable() {
public void run() { public void run() {
try { try {
Thread.sleep(100); Thread.sleep(100);
Jedis j = createJedis(); Jedis j = createJedis();
j.lpush("foo", "a"); j.lpush("foo", "a");
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
})).start(); })).start();
byte[] brpoplpush = jedis.brpoplpush("foo".getBytes(), byte[] brpoplpush = jedis.brpoplpush("foo".getBytes(),
"bar".getBytes(), 0); "bar".getBytes(), 0);
assertTrue(Arrays.equals("a".getBytes(), brpoplpush)); assertTrue(Arrays.equals("a".getBytes(), brpoplpush));
assertEquals(1, jedis.llen("bar").longValue()); assertEquals(1, jedis.llen("bar").longValue());
assertEquals("a", jedis.lrange("bar", 0, -1).get(0)); assertEquals("a", jedis.lrange("bar", 0, -1).get(0));
} }
} }

144
src/test/java/redis/clients/jedis/tests/commands/PublishSubscribeCommandsTest.java
View File

@@ -3,16 +3,17 @@ package redis.clients.jedis.tests.commands;
import java.io.IOException; import java.io.IOException;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.Ignore;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.BinaryJedisPubSub; import redis.clients.jedis.BinaryJedisPubSub;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub; import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.exceptions.JedisConnectionException; import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
public class PublishSubscribeCommandsTest extends JedisCommandTestBase { public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
@@ -29,7 +30,7 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
}); });
t.start(); t.start();
} }
@Test @Test
public void subscribe() throws InterruptedException { public void subscribe() throws InterruptedException {
jedis.subscribe(new JedisPubSub() { jedis.subscribe(new JedisPubSub() {
@@ -42,8 +43,8 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
public void onSubscribe(String channel, int subscribedChannels) { public void onSubscribe(String channel, int subscribedChannels) {
assertEquals("foo", channel); assertEquals("foo", channel);
assertEquals(1, subscribedChannels); assertEquals(1, subscribedChannels);
//now that I'm subscribed... publish // now that I'm subscribed... publish
publishOne("foo", "exit"); publishOne("foo", "exit");
} }
@@ -63,6 +64,124 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
} }
}, "foo"); }, "foo");
} }
@Test
public void pubSubChannels(){
final List<String> expectedActiveChannels = Arrays.asList("testchan1", "testchan2", "testchan3");
jedis.subscribe(new JedisPubSub() {
private int count = 0;
@Override
public void onUnsubscribe(String channel, int subscribedChannels) {
}
@Override
public void onSubscribe(String channel, int subscribedChannels) {
count++;
//All channels are subscribed
if (count == 3) {
Jedis otherJedis = createJedis();
List<String> activeChannels = otherJedis.pubsubChannels("test*");
assertTrue(expectedActiveChannels.containsAll(activeChannels));
unsubscribe();
}
}
@Override
public void onPUnsubscribe(String pattern, int subscribedChannels) {
}
@Override
public void onPSubscribe(String pattern, int subscribedChannels) {
}
@Override
public void onPMessage(String pattern, String channel, String message) {
}
@Override
public void onMessage(String channel, String message) {
}
}, "testchan1", "testchan2", "testchan3");
}
@Test
public void pubSubNumPat(){
jedis.psubscribe(new JedisPubSub() {
private int count=0;
@Override
public void onUnsubscribe(String channel, int subscribedChannels) {
}
@Override
public void onSubscribe(String channel, int subscribedChannels) {
}
@Override
public void onPUnsubscribe(String pattern, int subscribedChannels) {
}
@Override
public void onPSubscribe(String pattern, int subscribedChannels) {
count++;
if (count == 3) {
Jedis otherJedis = createJedis();
Long numPatterns = otherJedis.pubsubNumPat();
assertEquals(new Long(2l), numPatterns);
punsubscribe();
}
}
@Override
public void onPMessage(String pattern, String channel, String message) {
}
@Override
public void onMessage(String channel, String message) {
}
}, "test*", "test*", "chan*");
}
@Test
public void pubSubNumSub(){
final Map<String, String> expectedNumSub = new HashMap<String, String>();
expectedNumSub.put("testchannel2", "1");
expectedNumSub.put("testchannel1", "1");
jedis.subscribe(new JedisPubSub() {
private int count=0;
@Override
public void onUnsubscribe(String channel, int subscribedChannels) {
}
@Override
public void onSubscribe(String channel, int subscribedChannels) {
count++;
if (count == 2) {
Jedis otherJedis = createJedis();
Map<String, String> numSub = otherJedis.pubsubNumSub("testchannel1", "testchannel2");
assertEquals(expectedNumSub, numSub);
unsubscribe();
}
}
@Override
public void onPUnsubscribe(String pattern, int subscribedChannels) {
}
@Override
public void onPSubscribe(String pattern, int subscribedChannels) {
}
@Override
public void onPMessage(String pattern, String channel, String message) {
}
@Override
public void onMessage(String channel, String message) {
}
}, "testchannel1", "testchannel2");
}
@Test @Test
public void subscribeMany() throws UnknownHostException, IOException, public void subscribeMany() throws UnknownHostException, IOException,
@@ -140,7 +259,7 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
} }
public void onPSubscribe(String pattern, int subscribedChannels) { public void onPSubscribe(String pattern, int subscribedChannels) {
publishOne(pattern.replace("*", "123"), "exit"); publishOne(pattern.replace("*", "123"), "exit");
} }
public void onPUnsubscribe(String pattern, int subscribedChannels) { public void onPUnsubscribe(String pattern, int subscribedChannels) {
@@ -264,7 +383,8 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
public void onPSubscribe(byte[] pattern, int subscribedChannels) { public void onPSubscribe(byte[] pattern, int subscribedChannels) {
assertTrue(Arrays.equals(SafeEncoder.encode("foo.*"), pattern)); assertTrue(Arrays.equals(SafeEncoder.encode("foo.*"), pattern));
assertEquals(1, subscribedChannels); assertEquals(1, subscribedChannels);
publishOne(SafeEncoder.encode(pattern).replace("*", "bar"), "exit"); publishOne(SafeEncoder.encode(pattern).replace("*", "bar"),
"exit");
} }
public void onPUnsubscribe(byte[] pattern, int subscribedChannels) { public void onPUnsubscribe(byte[] pattern, int subscribedChannels) {
@@ -297,7 +417,8 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
} }
public void onPSubscribe(byte[] pattern, int subscribedChannels) { public void onPSubscribe(byte[] pattern, int subscribedChannels) {
publishOne(SafeEncoder.encode(pattern).replace("*", "123"), "exit"); publishOne(SafeEncoder.encode(pattern).replace("*", "123"),
"exit");
} }
public void onPUnsubscribe(byte[] pattern, int subscribedChannels) { public void onPUnsubscribe(byte[] pattern, int subscribedChannels) {
@@ -320,8 +441,8 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
public void onSubscribe(byte[] channel, int subscribedChannels) { public void onSubscribe(byte[] channel, int subscribedChannels) {
publishOne(SafeEncoder.encode(channel), "exit"); publishOne(SafeEncoder.encode(channel), "exit");
if(!SafeEncoder.encode(channel).equals("bar")) { if (!SafeEncoder.encode(channel).equals("bar")) {
this.subscribe(SafeEncoder.encode("bar")); this.subscribe(SafeEncoder.encode("bar"));
this.psubscribe(SafeEncoder.encode("bar.*")); this.psubscribe(SafeEncoder.encode("bar.*"));
} }
@@ -331,7 +452,8 @@ public class PublishSubscribeCommandsTest extends JedisCommandTestBase {
} }
public void onPSubscribe(byte[] pattern, int subscribedChannels) { public void onPSubscribe(byte[] pattern, int subscribedChannels) {
publishOne(SafeEncoder.encode(pattern).replace("*", "123"), "exit"); publishOne(SafeEncoder.encode(pattern).replace("*", "123"),
"exit");
} }
public void onPUnsubscribe(byte[] pattern, int subscribedChannels) { public void onPUnsubscribe(byte[] pattern, int subscribedChannels) {

83
src/test/java/redis/clients/jedis/tests/commands/ScriptingCommandsTest.java
View File

@@ -33,31 +33,33 @@ public class ScriptingCommandsTest extends JedisCommandTestBase {
assertEquals("second", response.get(3)); assertEquals("second", response.get(3));
assertEquals("third", response.get(4)); assertEquals("third", response.get(4));
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Test @Test
public void evalMultiBulkWithBinaryJedis() { public void evalMultiBulkWithBinaryJedis() {
String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2],ARGV[3]}"; String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2],ARGV[3]}";
List<byte[]> keys = new ArrayList<byte[]>(); List<byte[]> keys = new ArrayList<byte[]>();
keys.add("key1".getBytes()); keys.add("key1".getBytes());
keys.add("key2".getBytes()); keys.add("key2".getBytes());
List<byte[]> args = new ArrayList<byte[]>(); List<byte[]> args = new ArrayList<byte[]>();
args.add("first".getBytes()); args.add("first".getBytes());
args.add("second".getBytes()); args.add("second".getBytes());
args.add("third".getBytes()); args.add("third".getBytes());
BinaryJedis binaryJedis = new BinaryJedis(hnp.getHost(), hnp.getPort(), 500); BinaryJedis binaryJedis = new BinaryJedis(hnp.getHost(), hnp.getPort(),
binaryJedis.connect(); 500);
binaryJedis.auth("foobared"); binaryJedis.connect();
binaryJedis.auth("foobared");
List<byte[]> responses = (List<byte[]>) binaryJedis.eval(script.getBytes(), keys, args);
assertEquals(5, responses.size()); List<byte[]> responses = (List<byte[]>) binaryJedis.eval(
assertEquals("key1", new String(responses.get(0))); script.getBytes(), keys, args);
assertEquals("key2", new String(responses.get(1))); assertEquals(5, responses.size());
assertEquals("first", new String(responses.get(2))); assertEquals("key1", new String(responses.get(0)));
assertEquals("second", new String(responses.get(3))); assertEquals("key2", new String(responses.get(1)));
assertEquals("third", new String(responses.get(4))); assertEquals("first", new String(responses.get(2)));
assertEquals("second", new String(responses.get(3)));
assertEquals("third", new String(responses.get(4)));
} }
@Test @Test
@@ -166,26 +168,27 @@ public class ScriptingCommandsTest extends JedisCommandTestBase {
} }
} }
@Test @Test
public void scriptEvalReturnNullValues() { public void scriptEvalReturnNullValues() {
String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}"; String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
List<String> results = (List<String>) jedis.eval(script, 2, "key1", "key2", "1", "2"); List<String> results = (List<String>) jedis.eval(script, 2, "key1",
assertEquals(results.get(0), "key1"); "key2", "1", "2");
assertEquals(results.get(1), "key2"); assertEquals(results.get(0), "key1");
assertEquals(results.get(2), "1"); assertEquals(results.get(1), "key2");
assertEquals(results.get(3), "2"); assertEquals(results.get(2), "1");
} assertEquals(results.get(3), "2");
}
@Test @Test
public void scriptEvalShaReturnNullValues() { public void scriptEvalShaReturnNullValues() {
String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}"; String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
String sha = jedis.scriptLoad(script); String sha = jedis.scriptLoad(script);
List<String> results = (List<String>) jedis.evalsha(sha, 2, "key1", "key2", "1", "2"); List<String> results = (List<String>) jedis.evalsha(sha, 2, "key1",
assertEquals(results.get(0), "key1"); "key2", "1", "2");
assertEquals(results.get(1), "key2"); assertEquals(results.get(0), "key1");
assertEquals(results.get(2), "1"); assertEquals(results.get(1), "key2");
assertEquals(results.get(3), "2"); assertEquals(results.get(2), "1");
assertEquals(results.get(3), "2");
} }
} }

516
src/test/java/redis/clients/jedis/tests/commands/SetCommandsTest.java
View File

@@ -2,7 +2,6 @@ package redis.clients.jedis.tests.commands;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashSet; import java.util.HashSet;
import java.util.Map;
import java.util.Set; import java.util.Set;
import org.junit.Test; import org.junit.Test;
@@ -22,443 +21,442 @@ public class SetCommandsTest extends JedisCommandTestBase {
@Test @Test
public void sadd() { public void sadd() {
long status = jedis.sadd("foo", "a"); long status = jedis.sadd("foo", "a");
assertEquals(1, status); assertEquals(1, status);
status = jedis.sadd("foo", "a"); status = jedis.sadd("foo", "a");
assertEquals(0, status); assertEquals(0, status);
long bstatus = jedis.sadd(bfoo, ba); long bstatus = jedis.sadd(bfoo, ba);
assertEquals(1, bstatus); assertEquals(1, bstatus);
bstatus = jedis.sadd(bfoo, ba); bstatus = jedis.sadd(bfoo, ba);
assertEquals(0, bstatus); assertEquals(0, bstatus);
} }
@Test @Test
public void smembers() { public void smembers() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
Set<String> members = jedis.smembers("foo"); Set<String> members = jedis.smembers("foo");
assertEquals(expected, members); assertEquals(expected, members);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
bexpected.add(ba); bexpected.add(ba);
Set<byte[]> bmembers = jedis.smembers(bfoo); Set<byte[]> bmembers = jedis.smembers(bfoo);
assertEquals(bexpected, bmembers); assertEquals(bexpected, bmembers);
} }
@Test @Test
public void srem() { public void srem() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
long status = jedis.srem("foo", "a"); long status = jedis.srem("foo", "a");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("b"); expected.add("b");
assertEquals(1, status); assertEquals(1, status);
assertEquals(expected, jedis.smembers("foo")); assertEquals(expected, jedis.smembers("foo"));
status = jedis.srem("foo", "bar"); status = jedis.srem("foo", "bar");
assertEquals(0, status); assertEquals(0, status);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
long bstatus = jedis.srem(bfoo, ba); long bstatus = jedis.srem(bfoo, ba);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertEquals(bexpected, jedis.smembers(bfoo)); assertEquals(bexpected, jedis.smembers(bfoo));
bstatus = jedis.srem(bfoo, bbar); bstatus = jedis.srem(bfoo, bbar);
assertEquals(0, bstatus); assertEquals(0, bstatus);
} }
@Test @Test
public void spop() { public void spop() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
String member = jedis.spop("foo"); String member = jedis.spop("foo");
assertTrue("a".equals(member) || "b".equals(member)); assertTrue("a".equals(member) || "b".equals(member));
assertEquals(1, jedis.smembers("foo").size()); assertEquals(1, jedis.smembers("foo").size());
member = jedis.spop("bar"); member = jedis.spop("bar");
assertNull(member); assertNull(member);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
byte[] bmember = jedis.spop(bfoo); byte[] bmember = jedis.spop(bfoo);
assertTrue(Arrays.equals(ba, bmember) || Arrays.equals(bb, bmember)); assertTrue(Arrays.equals(ba, bmember) || Arrays.equals(bb, bmember));
assertEquals(1, jedis.smembers(bfoo).size()); assertEquals(1, jedis.smembers(bfoo).size());
bmember = jedis.spop(bbar); bmember = jedis.spop(bbar);
assertNull(bmember); assertNull(bmember);
} }
@Test @Test
public void smove() { public void smove() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
long status = jedis.smove("foo", "bar", "a"); long status = jedis.smove("foo", "bar", "a");
Set<String> expectedSrc = new HashSet<String>(); Set<String> expectedSrc = new HashSet<String>();
expectedSrc.add("b"); expectedSrc.add("b");
Set<String> expectedDst = new HashSet<String>(); Set<String> expectedDst = new HashSet<String>();
expectedDst.add("c"); expectedDst.add("c");
expectedDst.add("a"); expectedDst.add("a");
assertEquals(status, 1); assertEquals(status, 1);
assertEquals(expectedSrc, jedis.smembers("foo")); assertEquals(expectedSrc, jedis.smembers("foo"));
assertEquals(expectedDst, jedis.smembers("bar")); assertEquals(expectedDst, jedis.smembers("bar"));
status = jedis.smove("foo", "bar", "a"); status = jedis.smove("foo", "bar", "a");
assertEquals(status, 0); assertEquals(status, 0);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
long bstatus = jedis.smove(bfoo, bbar, ba); long bstatus = jedis.smove(bfoo, bbar, ba);
Set<byte[]> bexpectedSrc = new HashSet<byte[]>(); Set<byte[]> bexpectedSrc = new HashSet<byte[]>();
bexpectedSrc.add(bb); bexpectedSrc.add(bb);
Set<byte[]> bexpectedDst = new HashSet<byte[]>(); Set<byte[]> bexpectedDst = new HashSet<byte[]>();
bexpectedDst.add(bc); bexpectedDst.add(bc);
bexpectedDst.add(ba); bexpectedDst.add(ba);
assertEquals(bstatus, 1); assertEquals(bstatus, 1);
assertEquals(bexpectedSrc, jedis.smembers(bfoo)); assertEquals(bexpectedSrc, jedis.smembers(bfoo));
assertEquals(bexpectedDst, jedis.smembers(bbar)); assertEquals(bexpectedDst, jedis.smembers(bbar));
bstatus = jedis.smove(bfoo, bbar, ba); bstatus = jedis.smove(bfoo, bbar, ba);
assertEquals(bstatus, 0); assertEquals(bstatus, 0);
} }
@Test @Test
public void scard() { public void scard() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
long card = jedis.scard("foo"); long card = jedis.scard("foo");
assertEquals(2, card); assertEquals(2, card);
card = jedis.scard("bar"); card = jedis.scard("bar");
assertEquals(0, card); assertEquals(0, card);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
long bcard = jedis.scard(bfoo); long bcard = jedis.scard(bfoo);
assertEquals(2, bcard); assertEquals(2, bcard);
bcard = jedis.scard(bbar); bcard = jedis.scard(bbar);
assertEquals(0, bcard); assertEquals(0, bcard);
} }
@Test @Test
public void sismember() { public void sismember() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
assertTrue(jedis.sismember("foo", "a")); assertTrue(jedis.sismember("foo", "a"));
assertFalse(jedis.sismember("foo", "c")); assertFalse(jedis.sismember("foo", "c"));
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
assertTrue(jedis.sismember(bfoo, ba)); assertTrue(jedis.sismember(bfoo, ba));
assertFalse(jedis.sismember(bfoo, bc)); assertFalse(jedis.sismember(bfoo, bc));
} }
@Test @Test
public void sinter() { public void sinter() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("bar", "b"); jedis.sadd("bar", "b");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("b"); expected.add("b");
Set<String> intersection = jedis.sinter("foo", "bar"); Set<String> intersection = jedis.sinter("foo", "bar");
assertEquals(expected, intersection); assertEquals(expected, intersection);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bbar, bb); jedis.sadd(bbar, bb);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
Set<byte[]> bintersection = jedis.sinter(bfoo, bbar); Set<byte[]> bintersection = jedis.sinter(bfoo, bbar);
assertEquals(bexpected, bintersection); assertEquals(bexpected, bintersection);
} }
@Test @Test
public void sinterstore() { public void sinterstore() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("bar", "b"); jedis.sadd("bar", "b");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("b"); expected.add("b");
long status = jedis.sinterstore("car", "foo", "bar"); long status = jedis.sinterstore("car", "foo", "bar");
assertEquals(1, status); assertEquals(1, status);
assertEquals(expected, jedis.smembers("car")); assertEquals(expected, jedis.smembers("car"));
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bbar, bb); jedis.sadd(bbar, bb);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
long bstatus = jedis.sinterstore(bcar, bfoo, bbar); long bstatus = jedis.sinterstore(bcar, bfoo, bbar);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertEquals(bexpected, jedis.smembers(bcar)); assertEquals(bexpected, jedis.smembers(bcar));
} }
@Test @Test
public void sunion() { public void sunion() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("bar", "b"); jedis.sadd("bar", "b");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
Set<String> union = jedis.sunion("foo", "bar"); Set<String> union = jedis.sunion("foo", "bar");
assertEquals(expected, union); assertEquals(expected, union);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bbar, bb); jedis.sadd(bbar, bb);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
bexpected.add(bc); bexpected.add(bc);
bexpected.add(ba); bexpected.add(ba);
Set<byte[]> bunion = jedis.sunion(bfoo, bbar); Set<byte[]> bunion = jedis.sunion(bfoo, bbar);
assertEquals(bexpected, bunion); assertEquals(bexpected, bunion);
} }
@Test @Test
public void sunionstore() { public void sunionstore() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("bar", "b"); jedis.sadd("bar", "b");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
expected.add("c"); expected.add("c");
long status = jedis.sunionstore("car", "foo", "bar"); long status = jedis.sunionstore("car", "foo", "bar");
assertEquals(3, status); assertEquals(3, status);
assertEquals(expected, jedis.smembers("car")); assertEquals(expected, jedis.smembers("car"));
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bbar, bb); jedis.sadd(bbar, bb);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
bexpected.add(bc); bexpected.add(bc);
bexpected.add(ba); bexpected.add(ba);
long bstatus = jedis.sunionstore(bcar, bfoo, bbar); long bstatus = jedis.sunionstore(bcar, bfoo, bbar);
assertEquals(3, bstatus); assertEquals(3, bstatus);
assertEquals(bexpected, jedis.smembers(bcar)); assertEquals(bexpected, jedis.smembers(bcar));
} }
@Test @Test
public void sdiff() { public void sdiff() {
jedis.sadd("foo", "x"); jedis.sadd("foo", "x");
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("foo", "c"); jedis.sadd("foo", "c");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
jedis.sadd("car", "a"); jedis.sadd("car", "a");
jedis.sadd("car", "d"); jedis.sadd("car", "d");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("x"); expected.add("x");
expected.add("b"); expected.add("b");
Set<String> diff = jedis.sdiff("foo", "bar", "car"); Set<String> diff = jedis.sdiff("foo", "bar", "car");
assertEquals(expected, diff); assertEquals(expected, diff);
// Binary // Binary
jedis.sadd(bfoo, bx); jedis.sadd(bfoo, bx);
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bfoo, bc); jedis.sadd(bfoo, bc);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
jedis.sadd(bcar, ba); jedis.sadd(bcar, ba);
jedis.sadd(bcar, bd); jedis.sadd(bcar, bd);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bb); bexpected.add(bb);
bexpected.add(bx); bexpected.add(bx);
Set<byte[]> bdiff = jedis.sdiff(bfoo, bbar, bcar); Set<byte[]> bdiff = jedis.sdiff(bfoo, bbar, bcar);
assertEquals(bexpected, bdiff); assertEquals(bexpected, bdiff);
} }
@Test @Test
public void sdiffstore() { public void sdiffstore() {
jedis.sadd("foo", "x"); jedis.sadd("foo", "x");
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
jedis.sadd("foo", "c"); jedis.sadd("foo", "c");
jedis.sadd("bar", "c"); jedis.sadd("bar", "c");
jedis.sadd("car", "a"); jedis.sadd("car", "a");
jedis.sadd("car", "d"); jedis.sadd("car", "d");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("d"); expected.add("d");
expected.add("a"); expected.add("a");
long status = jedis.sdiffstore("tar", "foo", "bar", "car"); long status = jedis.sdiffstore("tar", "foo", "bar", "car");
assertEquals(2, status); assertEquals(2, status);
assertEquals(expected, jedis.smembers("car")); assertEquals(expected, jedis.smembers("car"));
// Binary // Binary
jedis.sadd(bfoo, bx); jedis.sadd(bfoo, bx);
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
jedis.sadd(bfoo, bc); jedis.sadd(bfoo, bc);
jedis.sadd(bbar, bc); jedis.sadd(bbar, bc);
jedis.sadd(bcar, ba); jedis.sadd(bcar, ba);
jedis.sadd(bcar, bd); jedis.sadd(bcar, bd);
Set<byte[]> bexpected = new HashSet<byte[]>(); Set<byte[]> bexpected = new HashSet<byte[]>();
bexpected.add(bd); bexpected.add(bd);
bexpected.add(ba); bexpected.add(ba);
long bstatus = jedis.sdiffstore("tar".getBytes(), bfoo, bbar, bcar); long bstatus = jedis.sdiffstore("tar".getBytes(), bfoo, bbar, bcar);
assertEquals(2, bstatus); assertEquals(2, bstatus);
assertEquals(bexpected, jedis.smembers(bcar)); assertEquals(bexpected, jedis.smembers(bcar));
} }
@Test @Test
public void srandmember() { public void srandmember() {
jedis.sadd("foo", "a"); jedis.sadd("foo", "a");
jedis.sadd("foo", "b"); jedis.sadd("foo", "b");
String member = jedis.srandmember("foo"); String member = jedis.srandmember("foo");
assertTrue("a".equals(member) || "b".equals(member)); assertTrue("a".equals(member) || "b".equals(member));
assertEquals(2, jedis.smembers("foo").size()); assertEquals(2, jedis.smembers("foo").size());
member = jedis.srandmember("bar"); member = jedis.srandmember("bar");
assertNull(member); assertNull(member);
// Binary // Binary
jedis.sadd(bfoo, ba); jedis.sadd(bfoo, ba);
jedis.sadd(bfoo, bb); jedis.sadd(bfoo, bb);
byte[] bmember = jedis.srandmember(bfoo); byte[] bmember = jedis.srandmember(bfoo);
assertTrue(Arrays.equals(ba, bmember) || Arrays.equals(bb, bmember)); assertTrue(Arrays.equals(ba, bmember) || Arrays.equals(bb, bmember));
assertEquals(2, jedis.smembers(bfoo).size()); assertEquals(2, jedis.smembers(bfoo).size());
bmember = jedis.srandmember(bbar); bmember = jedis.srandmember(bbar);
assertNull(bmember); assertNull(bmember);
} }
@Test @Test
public void sscan() { public void sscan() {
jedis.sadd("foo", "a", "b"); jedis.sadd("foo", "a", "b");
ScanResult<String> result = jedis.sscan("foo", 0); ScanResult<String> result = jedis.sscan("foo", 0);
assertEquals(0, result.getCursor()); assertEquals(0, result.getCursor());

68
src/test/java/redis/clients/jedis/tests/commands/SlowlogCommandsTest.java
View File

@@ -7,42 +7,42 @@ import org.junit.Test;
import redis.clients.util.Slowlog; import redis.clients.util.Slowlog;
public class SlowlogCommandsTest extends JedisCommandTestBase { public class SlowlogCommandsTest extends JedisCommandTestBase {
@Test @Test
public void slowlog() { public void slowlog() {
//do something // do something
jedis.configSet("slowlog-log-slower-than", "0"); jedis.configSet("slowlog-log-slower-than", "0");
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.set("foo2", "bar2"); jedis.set("foo2", "bar2");
List<Slowlog> reducedLog = jedis.slowlogGet(1); List<Slowlog> reducedLog = jedis.slowlogGet(1);
assertEquals(1, reducedLog.size()); assertEquals(1, reducedLog.size());
Slowlog log = reducedLog.get(0); Slowlog log = reducedLog.get(0);
assertTrue(log.getId() > 0); assertTrue(log.getId() > 0);
assertTrue(log.getTimeStamp() > 0); assertTrue(log.getTimeStamp() > 0);
assertTrue(log.getExecutionTime() > 0); assertTrue(log.getExecutionTime() > 0);
assertNotNull(log.getArgs()); assertNotNull(log.getArgs());
List<byte[]> breducedLog = jedis.slowlogGetBinary(1); List<byte[]> breducedLog = jedis.slowlogGetBinary(1);
assertEquals(1, breducedLog.size()); assertEquals(1, breducedLog.size());
List<Slowlog> log1 = jedis.slowlogGet(); List<Slowlog> log1 = jedis.slowlogGet();
List<byte[]> blog1 = jedis.slowlogGetBinary(); List<byte[]> blog1 = jedis.slowlogGetBinary();
assertNotNull(log1); assertNotNull(log1);
assertNotNull(blog1); assertNotNull(blog1);
long len1 = jedis.slowlogLen(); long len1 = jedis.slowlogLen();
jedis.slowlogReset(); jedis.slowlogReset();
List<Slowlog> log2 = jedis.slowlogGet(); List<Slowlog> log2 = jedis.slowlogGet();
List<byte[]> blog2 = jedis.slowlogGetBinary(); List<byte[]> blog2 = jedis.slowlogGetBinary();
long len2 = jedis.slowlogLen(); long len2 = jedis.slowlogLen();
assertTrue(len1 > len2); assertTrue(len1 > len2);
assertTrue(log1.size() > log2.size()); assertTrue(log1.size() > log2.size());
assertTrue(blog1.size() > blog2.size()); assertTrue(blog1.size() > blog2.size());
} }
} }

1098
src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
View File

File diff suppressed because it is too large Load Diff

362
src/test/java/redis/clients/jedis/tests/commands/SortingCommandsTest.java
View File

@@ -25,277 +25,277 @@ public class SortingCommandsTest extends JedisCommandTestBase {
@Test @Test
public void sort() { public void sort() {
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
List<String> result = jedis.sort("foo"); List<String> result = jedis.sort("foo");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("1"); expected.add("1");
expected.add("2"); expected.add("2");
expected.add("3"); expected.add("3");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
List<byte[]> bresult = jedis.sort(bfoo); List<byte[]> bresult = jedis.sort(bfoo);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b1); bexpected.add(b1);
bexpected.add(b2); bexpected.add(b2);
bexpected.add(b3); bexpected.add(b3);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortBy() { public void sortBy() {
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.set("bar1", "3"); jedis.set("bar1", "3");
jedis.set("bar2", "2"); jedis.set("bar2", "2");
jedis.set("bar3", "1"); jedis.set("bar3", "1");
SortingParams sp = new SortingParams(); SortingParams sp = new SortingParams();
sp.by("bar*"); sp.by("bar*");
List<String> result = jedis.sort("foo", sp); List<String> result = jedis.sort("foo", sp);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("3"); expected.add("3");
expected.add("2"); expected.add("2");
expected.add("1"); expected.add("1");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.set(bbar1, b3); jedis.set(bbar1, b3);
jedis.set(bbar2, b2); jedis.set(bbar2, b2);
jedis.set(bbar3, b1); jedis.set(bbar3, b1);
SortingParams bsp = new SortingParams(); SortingParams bsp = new SortingParams();
bsp.by(bbarstar); bsp.by(bbarstar);
List<byte[]> bresult = jedis.sort(bfoo, bsp); List<byte[]> bresult = jedis.sort(bfoo, bsp);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b3); bexpected.add(b3);
bexpected.add(b2); bexpected.add(b2);
bexpected.add(b1); bexpected.add(b1);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortDesc() { public void sortDesc() {
jedis.lpush("foo", "3"); jedis.lpush("foo", "3");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
SortingParams sp = new SortingParams(); SortingParams sp = new SortingParams();
sp.desc(); sp.desc();
List<String> result = jedis.sort("foo", sp); List<String> result = jedis.sort("foo", sp);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("3"); expected.add("3");
expected.add("2"); expected.add("2");
expected.add("1"); expected.add("1");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.lpush(bfoo, b3); jedis.lpush(bfoo, b3);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
SortingParams bsp = new SortingParams(); SortingParams bsp = new SortingParams();
bsp.desc(); bsp.desc();
List<byte[]> bresult = jedis.sort(bfoo, bsp); List<byte[]> bresult = jedis.sort(bfoo, bsp);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b3); bexpected.add(b3);
bexpected.add(b2); bexpected.add(b2);
bexpected.add(b1); bexpected.add(b1);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortLimit() { public void sortLimit() {
for (int n = 10; n > 0; n--) { for (int n = 10; n > 0; n--) {
jedis.lpush("foo", String.valueOf(n)); jedis.lpush("foo", String.valueOf(n));
} }
SortingParams sp = new SortingParams(); SortingParams sp = new SortingParams();
sp.limit(0, 3); sp.limit(0, 3);
List<String> result = jedis.sort("foo", sp); List<String> result = jedis.sort("foo", sp);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("1"); expected.add("1");
expected.add("2"); expected.add("2");
expected.add("3"); expected.add("3");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.rpush(bfoo, new byte[] { (byte) '4' }); jedis.rpush(bfoo, new byte[] { (byte) '4' });
jedis.rpush(bfoo, new byte[] { (byte) '3' }); jedis.rpush(bfoo, new byte[] { (byte) '3' });
jedis.rpush(bfoo, new byte[] { (byte) '2' }); jedis.rpush(bfoo, new byte[] { (byte) '2' });
jedis.rpush(bfoo, new byte[] { (byte) '1' }); jedis.rpush(bfoo, new byte[] { (byte) '1' });
SortingParams bsp = new SortingParams(); SortingParams bsp = new SortingParams();
bsp.limit(0, 3); bsp.limit(0, 3);
List<byte[]> bresult = jedis.sort(bfoo, bsp); List<byte[]> bresult = jedis.sort(bfoo, bsp);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b1); bexpected.add(b1);
bexpected.add(b2); bexpected.add(b2);
bexpected.add(b3); bexpected.add(b3);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortAlpha() { public void sortAlpha() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "10"); jedis.lpush("foo", "10");
SortingParams sp = new SortingParams(); SortingParams sp = new SortingParams();
sp.alpha(); sp.alpha();
List<String> result = jedis.sort("foo", sp); List<String> result = jedis.sort("foo", sp);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("1"); expected.add("1");
expected.add("10"); expected.add("10");
expected.add("2"); expected.add("2");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b10); jedis.lpush(bfoo, b10);
SortingParams bsp = new SortingParams(); SortingParams bsp = new SortingParams();
bsp.alpha(); bsp.alpha();
List<byte[]> bresult = jedis.sort(bfoo, bsp); List<byte[]> bresult = jedis.sort(bfoo, bsp);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b1); bexpected.add(b1);
bexpected.add(b10); bexpected.add(b10);
bexpected.add(b2); bexpected.add(b2);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortGet() { public void sortGet() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "10"); jedis.lpush("foo", "10");
jedis.set("bar1", "bar1"); jedis.set("bar1", "bar1");
jedis.set("bar2", "bar2"); jedis.set("bar2", "bar2");
jedis.set("bar10", "bar10"); jedis.set("bar10", "bar10");
jedis.set("car1", "car1"); jedis.set("car1", "car1");
jedis.set("car2", "car2"); jedis.set("car2", "car2");
jedis.set("car10", "car10"); jedis.set("car10", "car10");
SortingParams sp = new SortingParams(); SortingParams sp = new SortingParams();
sp.get("car*", "bar*"); sp.get("car*", "bar*");
List<String> result = jedis.sort("foo", sp); List<String> result = jedis.sort("foo", sp);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("car1"); expected.add("car1");
expected.add("bar1"); expected.add("bar1");
expected.add("car2"); expected.add("car2");
expected.add("bar2"); expected.add("bar2");
expected.add("car10"); expected.add("car10");
expected.add("bar10"); expected.add("bar10");
assertEquals(expected, result); assertEquals(expected, result);
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b10); jedis.lpush(bfoo, b10);
jedis.set(bbar1, bbar1); jedis.set(bbar1, bbar1);
jedis.set(bbar2, bbar2); jedis.set(bbar2, bbar2);
jedis.set(bbar10, bbar10); jedis.set(bbar10, bbar10);
jedis.set(bcar1, bcar1); jedis.set(bcar1, bcar1);
jedis.set(bcar2, bcar2); jedis.set(bcar2, bcar2);
jedis.set(bcar10, bcar10); jedis.set(bcar10, bcar10);
SortingParams bsp = new SortingParams(); SortingParams bsp = new SortingParams();
bsp.get(bcarstar, bbarstar); bsp.get(bcarstar, bbarstar);
List<byte[]> bresult = jedis.sort(bfoo, bsp); List<byte[]> bresult = jedis.sort(bfoo, bsp);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bcar1); bexpected.add(bcar1);
bexpected.add(bbar1); bexpected.add(bbar1);
bexpected.add(bcar2); bexpected.add(bcar2);
bexpected.add(bbar2); bexpected.add(bbar2);
bexpected.add(bcar10); bexpected.add(bcar10);
bexpected.add(bbar10); bexpected.add(bbar10);
assertEquals(bexpected, bresult); assertEquals(bexpected, bresult);
} }
@Test @Test
public void sortStore() { public void sortStore() {
jedis.lpush("foo", "1"); jedis.lpush("foo", "1");
jedis.lpush("foo", "2"); jedis.lpush("foo", "2");
jedis.lpush("foo", "10"); jedis.lpush("foo", "10");
long result = jedis.sort("foo", "result"); long result = jedis.sort("foo", "result");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("1"); expected.add("1");
expected.add("2"); expected.add("2");
expected.add("10"); expected.add("10");
assertEquals(3, result); assertEquals(3, result);
assertEquals(expected, jedis.lrange("result", 0, 1000)); assertEquals(expected, jedis.lrange("result", 0, 1000));
// Binary // Binary
jedis.lpush(bfoo, b1); jedis.lpush(bfoo, b1);
jedis.lpush(bfoo, b2); jedis.lpush(bfoo, b2);
jedis.lpush(bfoo, b10); jedis.lpush(bfoo, b10);
byte[] bkresult = new byte[] { 0X09, 0x0A, 0x0B, 0x0C }; byte[] bkresult = new byte[] { 0X09, 0x0A, 0x0B, 0x0C };
long bresult = jedis.sort(bfoo, bkresult); long bresult = jedis.sort(bfoo, bkresult);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(b1); bexpected.add(b1);
bexpected.add(b2); bexpected.add(b2);
bexpected.add(b10); bexpected.add(b10);
assertEquals(3, bresult); assertEquals(3, bresult);
assertEquals(bexpected, jedis.lrange(bkresult, 0, 1000)); assertEquals(bexpected, jedis.lrange(bkresult, 0, 1000));
} }
} }

204
src/test/java/redis/clients/jedis/tests/commands/StringValuesCommandsTest.java
View File

@@ -10,200 +10,200 @@ import redis.clients.jedis.exceptions.JedisDataException;
public class StringValuesCommandsTest extends JedisCommandTestBase { public class StringValuesCommandsTest extends JedisCommandTestBase {
@Test @Test
public void setAndGet() { public void setAndGet() {
String status = jedis.set("foo", "bar"); String status = jedis.set("foo", "bar");
assertEquals("OK", status); assertEquals("OK", status);
String value = jedis.get("foo"); String value = jedis.get("foo");
assertEquals("bar", value); assertEquals("bar", value);
assertEquals(null, jedis.get("bar")); assertEquals(null, jedis.get("bar"));
} }
@Test @Test
public void getSet() { public void getSet() {
String value = jedis.getSet("foo", "bar"); String value = jedis.getSet("foo", "bar");
assertEquals(null, value); assertEquals(null, value);
value = jedis.get("foo"); value = jedis.get("foo");
assertEquals("bar", value); assertEquals("bar", value);
} }
@Test @Test
public void mget() { public void mget() {
List<String> values = jedis.mget("foo", "bar"); List<String> values = jedis.mget("foo", "bar");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add(null); expected.add(null);
expected.add(null); expected.add(null);
assertEquals(expected, values); assertEquals(expected, values);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
expected = new ArrayList<String>(); expected = new ArrayList<String>();
expected.add("bar"); expected.add("bar");
expected.add(null); expected.add(null);
values = jedis.mget("foo", "bar"); values = jedis.mget("foo", "bar");
assertEquals(expected, values); assertEquals(expected, values);
jedis.set("bar", "foo"); jedis.set("bar", "foo");
expected = new ArrayList<String>(); expected = new ArrayList<String>();
expected.add("bar"); expected.add("bar");
expected.add("foo"); expected.add("foo");
values = jedis.mget("foo", "bar"); values = jedis.mget("foo", "bar");
assertEquals(expected, values); assertEquals(expected, values);
} }
@Test @Test
public void setnx() { public void setnx() {
long status = jedis.setnx("foo", "bar"); long status = jedis.setnx("foo", "bar");
assertEquals(1, status); assertEquals(1, status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
status = jedis.setnx("foo", "bar2"); status = jedis.setnx("foo", "bar2");
assertEquals(0, status); assertEquals(0, status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
} }
@Test @Test
public void setex() { public void setex() {
String status = jedis.setex("foo", 20, "bar"); String status = jedis.setex("foo", 20, "bar");
assertEquals("OK", status); assertEquals("OK", status);
long ttl = jedis.ttl("foo"); long ttl = jedis.ttl("foo");
assertTrue(ttl > 0 && ttl <= 20); assertTrue(ttl > 0 && ttl <= 20);
} }
@Test @Test
public void mset() { public void mset() {
String status = jedis.mset("foo", "bar", "bar", "foo"); String status = jedis.mset("foo", "bar", "bar", "foo");
assertEquals("OK", status); assertEquals("OK", status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
assertEquals("foo", jedis.get("bar")); assertEquals("foo", jedis.get("bar"));
} }
@Test @Test
public void msetnx() { public void msetnx() {
long status = jedis.msetnx("foo", "bar", "bar", "foo"); long status = jedis.msetnx("foo", "bar", "bar", "foo");
assertEquals(1, status); assertEquals(1, status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
assertEquals("foo", jedis.get("bar")); assertEquals("foo", jedis.get("bar"));
status = jedis.msetnx("foo", "bar1", "bar2", "foo2"); status = jedis.msetnx("foo", "bar1", "bar2", "foo2");
assertEquals(0, status); assertEquals(0, status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
assertEquals("foo", jedis.get("bar")); assertEquals("foo", jedis.get("bar"));
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void incrWrongValue() { public void incrWrongValue() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.incr("foo"); jedis.incr("foo");
} }
@Test @Test
public void incr() { public void incr() {
long value = jedis.incr("foo"); long value = jedis.incr("foo");
assertEquals(1, value); assertEquals(1, value);
value = jedis.incr("foo"); value = jedis.incr("foo");
assertEquals(2, value); assertEquals(2, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void incrByWrongValue() { public void incrByWrongValue() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.incrBy("foo", 2); jedis.incrBy("foo", 2);
} }
@Test @Test
public void incrBy() { public void incrBy() {
long value = jedis.incrBy("foo", 2); long value = jedis.incrBy("foo", 2);
assertEquals(2, value); assertEquals(2, value);
value = jedis.incrBy("foo", 2); value = jedis.incrBy("foo", 2);
assertEquals(4, value); assertEquals(4, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void decrWrongValue() { public void decrWrongValue() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.decr("foo"); jedis.decr("foo");
} }
@Test @Test
public void decr() { public void decr() {
long value = jedis.decr("foo"); long value = jedis.decr("foo");
assertEquals(-1, value); assertEquals(-1, value);
value = jedis.decr("foo"); value = jedis.decr("foo");
assertEquals(-2, value); assertEquals(-2, value);
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void decrByWrongValue() { public void decrByWrongValue() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.decrBy("foo", 2); jedis.decrBy("foo", 2);
} }
@Test @Test
public void decrBy() { public void decrBy() {
long value = jedis.decrBy("foo", 2); long value = jedis.decrBy("foo", 2);
assertEquals(-2, value); assertEquals(-2, value);
value = jedis.decrBy("foo", 2); value = jedis.decrBy("foo", 2);
assertEquals(-4, value); assertEquals(-4, value);
} }
@Test @Test
public void append() { public void append() {
long value = jedis.append("foo", "bar"); long value = jedis.append("foo", "bar");
assertEquals(3, value); assertEquals(3, value);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
value = jedis.append("foo", "bar"); value = jedis.append("foo", "bar");
assertEquals(6, value); assertEquals(6, value);
assertEquals("barbar", jedis.get("foo")); assertEquals("barbar", jedis.get("foo"));
} }
@Test @Test
public void substr() { public void substr() {
jedis.set("s", "This is a string"); jedis.set("s", "This is a string");
assertEquals("This", jedis.substr("s", 0, 3)); assertEquals("This", jedis.substr("s", 0, 3));
assertEquals("ing", jedis.substr("s", -3, -1)); assertEquals("ing", jedis.substr("s", -3, -1));
assertEquals("This is a string", jedis.substr("s", 0, -1)); assertEquals("This is a string", jedis.substr("s", 0, -1));
assertEquals(" string", jedis.substr("s", 9, 100000)); assertEquals(" string", jedis.substr("s", 9, 100000));
} }
@Test @Test
public void strlen() { public void strlen() {
jedis.set("s", "This is a string"); jedis.set("s", "This is a string");
assertEquals("This is a string".length(), jedis.strlen("s").intValue()); assertEquals("This is a string".length(), jedis.strlen("s").intValue());
} }
@Test @Test
public void incrLargeNumbers() { public void incrLargeNumbers() {
long value = jedis.incr("foo"); long value = jedis.incr("foo");
assertEquals(1, value); assertEquals(1, value);
assertEquals(1L + Integer.MAX_VALUE, (long) jedis.incrBy("foo", assertEquals(1L + Integer.MAX_VALUE,
Integer.MAX_VALUE)); (long) jedis.incrBy("foo", Integer.MAX_VALUE));
} }
@Test(expected = JedisDataException.class) @Test(expected = JedisDataException.class)
public void incrReallyLargeNumbers() { public void incrReallyLargeNumbers() {
jedis.set("foo", Long.toString(Long.MAX_VALUE)); jedis.set("foo", Long.toString(Long.MAX_VALUE));
long value = jedis.incr("foo"); long value = jedis.incr("foo");
assertEquals(Long.MIN_VALUE, value); assertEquals(Long.MIN_VALUE, value);
} }
@Test @Test
public void incrByFloat() { public void incrByFloat() {
double value = jedis.incrByFloat("foo", 10.5); double value = jedis.incrByFloat("foo", 10.5);
assertEquals(10.5, value, 0.0); assertEquals(10.5, value, 0.0);
value = jedis.incrByFloat("foo", 0.1); value = jedis.incrByFloat("foo", 0.1);
assertEquals(10.6, value, 0.0); assertEquals(10.6, value, 0.0);
} }
@Test @Test
public void psetex() { public void psetex() {
String status = jedis.psetex("foo", 20000, "bar"); String status = jedis.psetex("foo", 20000, "bar");
assertEquals("OK", status); assertEquals("OK", status);
long ttl = jedis.ttl("foo"); long ttl = jedis.ttl("foo");
assertTrue(ttl > 0 && ttl <= 20000); assertTrue(ttl > 0 && ttl <= 20000);
} }
} }

93
src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
View File

@@ -4,6 +4,7 @@ import java.io.IOException;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
@@ -11,11 +12,13 @@ import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Protocol.Keyword; import redis.clients.jedis.Protocol.Keyword;
import redis.clients.jedis.Response; import redis.clients.jedis.Response;
import redis.clients.jedis.Transaction; import redis.clients.jedis.Transaction;
import redis.clients.jedis.TransactionBlock; import redis.clients.jedis.TransactionBlock;
import redis.clients.jedis.exceptions.JedisDataException; import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;
public class TransactionCommandsTest extends JedisCommandTestBase { public class TransactionCommandsTest extends JedisCommandTestBase {
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -105,6 +108,52 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
} }
@Test
public void multiBlockWithErrorRedisDiscardsTransaction() throws Exception {
// Transaction with error - Redis discards transaction automatically
// (Syntax Error, etc.)
TransactionBlock tb = new TransactionBlock() {
@Override
public void execute() throws JedisException {
del("hello");
hmset("hello", new HashMap<String, String>());
}
};
try {
jedis.multi(tb);
} catch (JedisDataException e) {
assertTrue(e.getMessage().contains("EXECABORT"));
} catch (Exception e) {
throw e;
}
}
@Test
public void multiBlockWithErrorRedisForceToExecuteAllCommands()
throws Exception {
// Transaction with error - Redis doesn't roll back (Type Error,
// Deletion of non-exist key, etc.)
jedis.del("hello2");
TransactionBlock tb2 = new TransactionBlock() {
@Override
public void execute() throws JedisException {
del("hello2");
set("hello2", "hello");
sadd("hello2", "hello2");
}
};
List<Object> responses = jedis.multi(tb2);
assertEquals("OK", responses.get(1));
assertEquals(JedisDataException.class, responses.get(2).getClass());
Exception exc = (JedisDataException) responses.get(2);
assertTrue(exc.getMessage().contains("WRONGTYPE"));
}
@Test @Test
public void watch() throws UnknownHostException, IOException { public void watch() throws UnknownHostException, IOException {
jedis.watch("mykey", "somekey"); jedis.watch("mykey", "somekey");
@@ -294,4 +343,48 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
assertNull(results); assertNull(results);
} }
@Test
public void testResetStateWhenInMulti() {
jedis.auth("foobared");
Transaction t = jedis.multi();
t.set("foooo", "barrr");
jedis.resetState();
assertEquals(null, jedis.get("foooo"));
}
@Test
public void testResetStateWhenInMultiWithinPipeline() {
jedis.auth("foobared");
Pipeline p = jedis.pipelined();
p.multi();
p.set("foooo", "barrr");
jedis.resetState();
assertEquals(null, jedis.get("foooo"));
}
@Test
public void testResetStateWhenInWatch() {
jedis.watch("mykey", "somekey");
// state reset : unwatch
jedis.resetState();
Transaction t = jedis.multi();
nj.connect();
nj.auth("foobared");
nj.set("mykey", "bar");
nj.disconnect();
t.set("mykey", "foo");
List<Object> resp = t.exec();
assertNotNull(resp);
assertEquals(1, resp.size());
assertEquals("foo", jedis.get("mykey"));
}
} }

266
src/test/java/redis/clients/jedis/tests/commands/VariadicCommandsTest.java
View File

@@ -10,181 +10,181 @@ import java.util.Set;
import org.junit.Test; import org.junit.Test;
public class VariadicCommandsTest extends JedisCommandTestBase { public class VariadicCommandsTest extends JedisCommandTestBase {
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 }; final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
final byte[] bcar = { 0x09, 0x0A, 0x0B, 0x0C }; final byte[] bcar = { 0x09, 0x0A, 0x0B, 0x0C };
final byte[] bfoo1 = { 0x01, 0x02, 0x03, 0x04, 0x0A }; final byte[] bfoo1 = { 0x01, 0x02, 0x03, 0x04, 0x0A };
final byte[] bfoo2 = { 0x01, 0x02, 0x03, 0x04, 0x0B }; final byte[] bfoo2 = { 0x01, 0x02, 0x03, 0x04, 0x0B };
@Test @Test
public void hdel() { public void hdel() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
hash.put("foo2", "bar"); hash.put("foo2", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
assertEquals(0, jedis.hdel("bar", "foo", "foo1").intValue()); assertEquals(0, jedis.hdel("bar", "foo", "foo1").intValue());
assertEquals(0, jedis.hdel("foo", "foo", "foo1").intValue()); assertEquals(0, jedis.hdel("foo", "foo", "foo1").intValue());
assertEquals(2, jedis.hdel("foo", "bar", "foo2").intValue()); assertEquals(2, jedis.hdel("foo", "bar", "foo2").intValue());
assertEquals(null, jedis.hget("foo", "bar")); assertEquals(null, jedis.hget("foo", "bar"));
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
bhash.put(bfoo2, bbar); bhash.put(bfoo2, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
assertEquals(0, jedis.hdel(bbar, bfoo, bfoo1).intValue()); assertEquals(0, jedis.hdel(bbar, bfoo, bfoo1).intValue());
assertEquals(0, jedis.hdel(bfoo, bfoo, bfoo1).intValue()); assertEquals(0, jedis.hdel(bfoo, bfoo, bfoo1).intValue());
assertEquals(2, jedis.hdel(bfoo, bbar, bfoo2).intValue()); assertEquals(2, jedis.hdel(bfoo, bbar, bfoo2).intValue());
assertEquals(null, jedis.hget(bfoo, bbar)); assertEquals(null, jedis.hget(bfoo, bbar));
} }
@Test @Test
public void rpush() { public void rpush() {
long size = jedis.rpush("foo", "bar", "foo"); long size = jedis.rpush("foo", "bar", "foo");
assertEquals(2, size); assertEquals(2, size);
List<String> expected = new ArrayList<String>();
expected.add("bar");
expected.add("foo");
List<String> values = jedis.lrange("foo",0,-1);
assertEquals(expected, values);
// Binary
size = jedis.rpush(bfoo, bbar, bfoo);
assertEquals(2, size);
List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bbar);
bexpected.add(bfoo);
List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1); List<String> expected = new ArrayList<String>();
assertEquals(bexpected, bvalues); expected.add("bar");
expected.add("foo");
List<String> values = jedis.lrange("foo", 0, -1);
assertEquals(expected, values);
// Binary
size = jedis.rpush(bfoo, bbar, bfoo);
assertEquals(2, size);
List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bbar);
bexpected.add(bfoo);
List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1);
assertEquals(bexpected, bvalues);
} }
@Test @Test
public void lpush() { public void lpush() {
long size = jedis.lpush("foo", "bar", "foo"); long size = jedis.lpush("foo", "bar", "foo");
assertEquals(2, size); assertEquals(2, size);
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("foo"); expected.add("foo");
expected.add("bar"); expected.add("bar");
List<String> values = jedis.lrange("foo",0,-1); List<String> values = jedis.lrange("foo", 0, -1);
assertEquals(expected, values); assertEquals(expected, values);
// Binary // Binary
size = jedis.lpush(bfoo, bbar, bfoo); size = jedis.lpush(bfoo, bbar, bfoo);
assertEquals(2, size); assertEquals(2, size);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bfoo); bexpected.add(bfoo);
bexpected.add(bbar); bexpected.add(bbar);
List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1);
assertEquals(bexpected, bvalues);
List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1);
assertEquals(bexpected, bvalues);
} }
@Test @Test
public void sadd() { public void sadd() {
long status = jedis.sadd("foo", "bar", "foo1"); long status = jedis.sadd("foo", "bar", "foo1");
assertEquals(2, status); assertEquals(2, status);
status = jedis.sadd("foo", "bar", "car"); status = jedis.sadd("foo", "bar", "car");
assertEquals(1, status); assertEquals(1, status);
status = jedis.sadd("foo", "bar", "foo1"); status = jedis.sadd("foo", "bar", "foo1");
assertEquals(0, status); assertEquals(0, status);
status = jedis.sadd(bfoo, bbar, bfoo1); status = jedis.sadd(bfoo, bbar, bfoo1);
assertEquals(2, status); assertEquals(2, status);
status = jedis.sadd(bfoo, bbar, bcar); status = jedis.sadd(bfoo, bbar, bcar);
assertEquals(1, status); assertEquals(1, status);
status = jedis.sadd(bfoo, bbar, bfoo1); status = jedis.sadd(bfoo, bbar, bfoo1);
assertEquals(0, status); assertEquals(0, status);
} }
@Test @Test
public void zadd() { public void zadd() {
Map<Double, String> scoreMembers = new HashMap<Double, String>(); Map<String, Double> scoreMembers = new HashMap<String, Double>();
scoreMembers.put(1d, "bar"); scoreMembers.put("bar", 1d);
scoreMembers.put(10d, "foo"); scoreMembers.put("foo", 10d);
long status = jedis.zadd("foo", scoreMembers);
assertEquals(2, status);
scoreMembers.clear(); long status = jedis.zadd("foo", scoreMembers);
scoreMembers.put(0.1d, "car"); assertEquals(2, status);
scoreMembers.put(2d, "bar");
status = jedis.zadd("foo", scoreMembers);
assertEquals(1, status);
Map<Double, byte[]> bscoreMembers = new HashMap<Double, byte[]>(); scoreMembers.clear();
bscoreMembers.put(1d, bbar); scoreMembers.put("car", 0.1d);
bscoreMembers.put(10d, bfoo); scoreMembers.put("bar", 2d);
status = jedis.zadd(bfoo, bscoreMembers);
assertEquals(2, status);
bscoreMembers.clear(); status = jedis.zadd("foo", scoreMembers);
bscoreMembers.put(0.1d, bcar); assertEquals(1, status);
bscoreMembers.put(2d, bbar);
Map<byte[], Double> bscoreMembers = new HashMap<byte[], Double>();
status = jedis.zadd(bfoo, bscoreMembers); bscoreMembers.put(bbar, 1d);
assertEquals(1, status); bscoreMembers.put(bfoo, 10d);
status = jedis.zadd(bfoo, bscoreMembers);
assertEquals(2, status);
bscoreMembers.clear();
bscoreMembers.put(bcar, 0.1d);
bscoreMembers.put(bbar, 2d);
status = jedis.zadd(bfoo, bscoreMembers);
assertEquals(1, status);
} }
@Test @Test
public void zrem() { public void zrem() {
jedis.zadd("foo", 1d, "bar"); jedis.zadd("foo", 1d, "bar");
jedis.zadd("foo", 2d, "car"); jedis.zadd("foo", 2d, "car");
jedis.zadd("foo", 3d, "foo1"); jedis.zadd("foo", 3d, "foo1");
long status = jedis.zrem("foo", "bar", "car"); long status = jedis.zrem("foo", "bar", "car");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("foo1"); expected.add("foo1");
assertEquals(2, status); assertEquals(2, status);
assertEquals(expected, jedis.zrange("foo", 0, 100)); assertEquals(expected, jedis.zrange("foo", 0, 100));
status = jedis.zrem("foo", "bar", "car"); status = jedis.zrem("foo", "bar", "car");
assertEquals(0, status); assertEquals(0, status);
status = jedis.zrem("foo", "bar", "foo1");
assertEquals(1, status);
//Binary status = jedis.zrem("foo", "bar", "foo1");
jedis.zadd(bfoo, 1d, bbar); assertEquals(1, status);
jedis.zadd(bfoo, 2d, bcar);
jedis.zadd(bfoo, 3d, bfoo1);
status = jedis.zrem(bfoo, bbar, bcar); // Binary
jedis.zadd(bfoo, 1d, bbar);
jedis.zadd(bfoo, 2d, bcar);
jedis.zadd(bfoo, 3d, bfoo1);
Set<byte[]> bexpected = new LinkedHashSet<byte[]>(); status = jedis.zrem(bfoo, bbar, bcar);
bexpected.add(bfoo);
assertEquals(2, status); Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
assertEquals(bexpected, jedis.zrange(bfoo, 0, 100)); bexpected.add(bfoo);
status = jedis.zrem(bfoo, bbar, bcar); assertEquals(2, status);
assertEquals(0, status); assertEquals(bexpected, jedis.zrange(bfoo, 0, 100));
status = jedis.zrem(bfoo, bbar, bfoo1);
assertEquals(1, status);
} status = jedis.zrem(bfoo, bbar, bcar);
assertEquals(0, status);
status = jedis.zrem(bfoo, bbar, bfoo1);
assertEquals(1, status);
}
} }