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

merging with master branch. Required refactoring of Pipeline code.

Browse Source
This commit is contained in:
Eric Treworgy
2013-02-20 12:24:15 -08:00
parent 610f7d4546 69f5340aa6
commit 6af41cdac2
40 changed files with 3397 additions and 3351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -8,3 +8,4 @@
target/
build/
bin/
tags

16
Makefile
View File

@@ -12,15 +12,31 @@ requirepass foobared
pidfile /tmp/redis2.pid
endef
define REDIS_SENTINEL1
port 26379
daemonize yes
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel auth-pass mymaster foobared
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 900000
sentinel can-failover mymaster yes
sentinel parallel-syncs mymaster 1
pidfile /tmp/sentinel1.pid
endef
export REDIS1_CONF
export REDIS2_CONF
export REDIS_SENTINEL1
test:
echo "$$REDIS1_CONF" | redis-server -
echo "$$REDIS2_CONF" | redis-server -
echo "$$REDIS_SENTINEL1" | redis-sentinel -
mvn clean compile test
kill `cat /tmp/redis1.pid`
kill `cat /tmp/redis2.pid`
kill `cat /tmp/sentinel1.pid`
.PHONY: test

25
src/main/java/redis/clients/jedis/AdvancedBinaryJedisCommands.java Normal file
View File

@@ -0,0 +1,25 @@
package redis.clients.jedis;
import java.util.List;
public interface AdvancedBinaryJedisCommands {
List<byte[]> configGet(byte[] pattern);
byte[] configSet(byte[] parameter, byte[] value);
String slowlogReset();
Long slowlogLen();
List<byte[]> slowlogGetBinary();
List<byte[]> slowlogGetBinary(long entries);
Long objectRefcount(byte[] key);
byte[] objectEncoding(byte[] key);
Long objectIdletime(byte[] key);
}

26
src/main/java/redis/clients/jedis/AdvancedJedisCommands.java Normal file
View File

@@ -0,0 +1,26 @@
package redis.clients.jedis;
import redis.clients.util.Slowlog;
import java.util.List;
public interface AdvancedJedisCommands {
List<String> configGet(String pattern);
String configSet(String parameter, String value);
String slowlogReset();
Long slowlogLen();
List<Slowlog> slowlogGet();
List<Slowlog> slowlogGet(long entries);
Long objectRefcount(String string);
String objectEncoding(String string);
Long objectIdletime(String string);
}

42
src/main/java/redis/clients/jedis/BasicCommands.java Normal file
View File

@@ -0,0 +1,42 @@
package redis.clients.jedis;
public interface BasicCommands {
String ping();
String quit();
String flushDB();
Long dbSize();
String select(int index);
String flushAll();
String auth(String password);
String save();
String bgsave();
String bgrewriteaof();
Long lastsave();
String shutdown();
String info();
String info(String section);
String slaveof(String host, int port);
String slaveofNoOne();
Long getDB();
String debug(DebugParams params);
String configResetStat();
}

38
src/main/java/redis/clients/jedis/BasicRedisPipeline.java Normal file
View File

@@ -0,0 +1,38 @@
package redis.clients.jedis;
import java.util.List;
/**
* Pipelined responses for all of the low level, non key related commands
*/
public interface BasicRedisPipeline {
Response<String> bgrewriteaof();
Response<String> bgsave();
Response<String> configGet(String pattern);
Response<String> configSet(String parameter, String value);
Response<String> configResetStat();
Response<String> save();
Response<Long> lastsave();
Response<String> flushDB();
Response<String> flushAll();
Response<String> info();
Response<Long> dbSize();
Response<String> shutdown();
Response<String> ping();
Response<String> select(int index);
}

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

@@ -79,7 +79,7 @@ public class BinaryClient extends Connection {
}
public void ping() {
sendCommand(PING);
sendCommand(Command.PING);
}
public void set(final byte[] key, final byte[] value) {
@@ -656,6 +656,10 @@ public class BinaryClient extends Connection {
public void info() {
sendCommand(INFO);
}
public void info(final String section) {
sendCommand(INFO, section);
}
public void monitor() {
sendCommand(MONITOR);
@@ -685,16 +689,16 @@ public class BinaryClient extends Connection {
sendCommand(SYNC);
}
public void lpushx(final byte[] key, final byte[] string) {
sendCommand(LPUSHX, key, string);
public void lpushx(final byte[] key, final byte[]... string) {
sendCommand(LPUSHX, joinParameters(key, string));
}
public void persist(final byte[] key) {
sendCommand(PERSIST, key);
}
public void rpushx(final byte[] key, final byte[] string) {
sendCommand(RPUSHX, key, string);
public void rpushx(final byte[] key, final byte[]... string) {
sendCommand(RPUSHX, joinParameters(key, string));
}
public void echo(final byte[] string) {
@@ -723,6 +727,10 @@ public class BinaryClient extends Connection {
sendCommand(SETBIT, key, toByteArray(offset), value);
}
public void setbit(byte[] key, long offset, boolean value) {
sendCommand(SETBIT, key, toByteArray(offset), toByteArray(value));
}
public void getbit(byte[] key, long offset) {
sendCommand(GETBIT, key, toByteArray(offset));
}
@@ -763,10 +771,18 @@ public class BinaryClient extends Connection {
sendEvalCommand(EVAL, script, keyCount, params);
}
public void evalsha(byte[] sha1, byte[] keyCount, byte[][] params) {
public void eval(byte[] script, int keyCount, byte[]... params) {
eval(script, toByteArray(keyCount), params);
}
public void evalsha(byte[] sha1, byte[] keyCount, byte[]... params) {
sendEvalCommand(EVALSHA, sha1, keyCount, params);
}
public void evalsha(byte[] sha1, int keyCount, byte[]... params) {
sendEvalCommand(EVALSHA, sha1, toByteArray(keyCount), params);
}
public void scriptFlush() {
sendCommand(SCRIPT, Keyword.FLUSH.raw);
}
@@ -815,4 +831,45 @@ public class BinaryClient extends Connection {
public void objectEncoding(byte[] key) {
sendCommand(OBJECT, ENCODING.raw, key);
}
public void bitcount(byte[] key) {
sendCommand(BITCOUNT, key);
}
public void bitcount(byte[] key, long start, long end) {
sendCommand(BITCOUNT, key, toByteArray(start), toByteArray(end));
}
public void bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
Keyword kw = Keyword.AND;
int len = srcKeys.length;
switch (op) {
case AND:
kw = Keyword.AND;
break;
case OR:
kw = Keyword.OR;
break;
case XOR:
kw = Keyword.XOR;
break;
case NOT:
kw = Keyword.NOT;
len = Math.min(1, len);
break;
}
byte[][] bargs = new byte[len + 2][];
bargs[0] = kw.raw;
bargs[1] = destKey;
for (int i = 0; i < len; ++i) {
bargs[i + 2] = srcKeys[i];
}
sendCommand(BITOP, bargs);
}
public void sentinel(final byte[]... args) {
sendCommand(SENTINEL, args);
}
}

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

@@ -17,7 +17,7 @@ import redis.clients.jedis.exceptions.JedisException;
import redis.clients.util.JedisByteHashMap;
import redis.clients.util.SafeEncoder;
public class BinaryJedis implements BinaryJedisCommands {
public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKeyBinaryCommands, AdvancedBinaryJedisCommands, BinaryScriptingCommands {
protected Client client = null;
public BinaryJedis(final String host) {
@@ -135,6 +135,12 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public Long del(final byte[] key) {
checkIsInMulti();
client.del(key);
return client.getIntegerReply();
}
/**
* Return the type of the value stored at key in form of a string. The type
* can be one of "none", "string", "list", "set". "none" is returned if the
@@ -1045,7 +1051,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @return Multi bulk reply, specifically a list of elements in the
* specified range.
*/
public List<byte[]> lrange(final byte[] key, final int start, final int end) {
public List<byte[]> lrange(final byte[] key, final long start, final long end) {
checkIsInMulti();
client.lrange(key, start, end);
return client.getBinaryMultiBulkReply();
@@ -1085,7 +1091,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @param end
* @return Status code reply
*/
public String ltrim(final byte[] key, final int start, final int end) {
public String ltrim(final byte[] key, final long start, final long end) {
checkIsInMulti();
client.ltrim(key, start, end);
return client.getStatusCodeReply();
@@ -1109,7 +1115,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @param index
* @return Bulk reply, specifically the requested element
*/
public byte[] lindex(final byte[] key, final int index) {
public byte[] lindex(final byte[] key, final long index) {
checkIsInMulti();
client.lindex(key, index);
return client.getBinaryBulkReply();
@@ -1136,7 +1142,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @param value
* @return Status code reply
*/
public String lset(final byte[] key, final int index, final byte[] value) {
public String lset(final byte[] key, final long index, final byte[] value) {
checkIsInMulti();
client.lset(key, index, value);
return client.getStatusCodeReply();
@@ -1161,7 +1167,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @return Integer Reply, specifically: The number of removed elements if
* the operation succeeded
*/
public Long lrem(final byte[] key, final int count, final byte[] value) {
public Long lrem(final byte[] key, final long count, final byte[] value) {
checkIsInMulti();
client.lrem(key, count, value);
return client.getIntegerReply();
@@ -1541,7 +1547,7 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public Set<byte[]> zrange(final byte[] key, final int start, final int end) {
public Set<byte[]> zrange(final byte[] key, final long start, final long end) {
checkIsInMulti();
client.zrange(key, start, end);
final List<byte[]> members = client.getBinaryMultiBulkReply();
@@ -1653,24 +1659,24 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public Set<byte[]> zrevrange(final byte[] key, final int start,
final int end) {
public Set<byte[]> zrevrange(final byte[] key, final long start,
final long end) {
checkIsInMulti();
client.zrevrange(key, start, end);
final List<byte[]> members = client.getBinaryMultiBulkReply();
return new LinkedHashSet<byte[]>(members);
}
public Set<Tuple> zrangeWithScores(final byte[] key, final int start,
final int end) {
public Set<Tuple> zrangeWithScores(final byte[] key, final long start,
final long end) {
checkIsInMulti();
client.zrangeWithScores(key, start, end);
Set<Tuple> set = getBinaryTupledSet();
return set;
}
public Set<Tuple> zrevrangeWithScores(final byte[] key, final int start,
final int end) {
public Set<Tuple> zrevrangeWithScores(final byte[] key, final long start,
final long end) {
checkIsInMulti();
client.zrevrangeWithScores(key, start, end);
Set<Tuple> set = getBinaryTupledSet();
@@ -2076,6 +2082,46 @@ public class BinaryJedis implements BinaryJedisCommands {
return multiBulkReply;
}
public List<byte[]> blpop(byte[] arg) {
checkIsInMulti();
byte[][] args = new byte[1][];
args[0] = arg;
client.blpop(args);
client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<byte[]> brpop(byte[] arg) {
checkIsInMulti();
byte[][] args = new byte[1][];
args[0] = arg;
client.brpop(args);
client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<byte[]> blpop(byte[]... args) {
checkIsInMulti();
client.blpop(args);
client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<byte[]> brpop(byte[]... args) {
checkIsInMulti();
client.brpop(args);
client.setTimeoutInfinite();
final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
/**
* Request for authentication in a password protected Redis server. A Redis
* server can be instructed to require a password before to allow clients to
@@ -2118,25 +2164,6 @@ public class BinaryJedis implements BinaryJedisCommands {
return pipeline;
}
public void subscribe(final JedisPubSub jedisPubSub,
final String... channels) {
client.setTimeoutInfinite();
jedisPubSub.proceed(client, channels);
client.rollbackTimeout();
}
public Long publish(final String channel, final String message) {
client.publish(channel, message);
return client.getIntegerReply();
}
public void psubscribe(final JedisPubSub jedisPubSub,
final String... patterns) {
client.setTimeoutInfinite();
jedisPubSub.proceedWithPatterns(client, patterns);
client.rollbackTimeout();
}
public Long zcount(final byte[] key, final double min, final double max) {
return zcount(key, toByteArray(min), toByteArray(max));
}
@@ -2500,7 +2527,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* operation
*
*/
public Long zremrangeByRank(final byte[] key, final int start, final int end) {
public Long zremrangeByRank(final byte[] key, final long start, final long end) {
checkIsInMulti();
client.zremrangeByRank(key, start, end);
return client.getIntegerReply();
@@ -2854,6 +2881,11 @@ public class BinaryJedis implements BinaryJedisCommands {
client.info();
return client.getBulkReply();
}
public String info(final String section) {
client.info(section);
return client.getBulkReply();
}
/**
* Dump all the received requests in real time.
@@ -3008,7 +3040,7 @@ public class BinaryJedis implements BinaryJedisCommands {
client.sync();
}
public Long lpushx(final byte[] key, final byte[] string) {
public Long lpushx(final byte[] key, final byte[]... string) {
client.lpushx(key, string);
return client.getIntegerReply();
}
@@ -3028,7 +3060,7 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public Long rpushx(final byte[] key, final byte[] string) {
public Long rpushx(final byte[] key, final byte[]... string) {
client.rpushx(key, string);
return client.getIntegerReply();
}
@@ -3078,11 +3110,16 @@ public class BinaryJedis implements BinaryJedisCommands {
* @param value
* @return
*/
public Boolean setbit(byte[] key, long offset, byte[] value) {
public Boolean setbit(byte[] key, long offset, boolean value) {
client.setbit(key, offset, value);
return client.getIntegerReply() == 1;
}
public Boolean setbit(byte[] key, long offset, byte[] value) {
client.setbit(key, offset, value);
return client.getIntegerReply() == 1;
}
/**
* Returns the bit value at offset in the string value stored at key
*
@@ -3100,9 +3137,9 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public String getrange(byte[] key, long startOffset, long endOffset) {
public byte[] getrange(byte[] key, long startOffset, long endOffset) {
client.getrange(key, startOffset, endOffset);
return client.getBulkReply();
return client.getBinaryBulkReply();
}
public Long publish(byte[] channel, byte[] message) {
@@ -3152,20 +3189,50 @@ public class BinaryJedis implements BinaryJedisCommands {
return params;
}
public Object eval(byte[] script, byte[] keyCount, byte[][] params) {
public Object eval(byte[] script, byte[] keyCount, byte[]... params) {
client.setTimeoutInfinite();
client.eval(script, keyCount, params);
return client.getOne();
}
public byte[] scriptFlush() {
public Object eval(byte[] script, int keyCount, byte[]... params) {
client.setTimeoutInfinite();
client.eval(script, SafeEncoder.encode(Integer.toString(keyCount)), params);
return client.getOne();
}
public Object eval(byte[] script) {
client.setTimeoutInfinite();
client.eval(script, 0);
return client.getOne();
}
public Object evalsha(byte[] sha1) {
client.setTimeoutInfinite();
client.evalsha(sha1, 0);
return client.getOne();
}
public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
client.setTimeoutInfinite();
client.evalsha(sha1, keys.size(), keys.toArray(new byte[0][]));
return client.getOne();
}
public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
client.setTimeoutInfinite();
client.evalsha(sha1, keyCount, params);
return client.getOne();
}
public String scriptFlush() {
client.scriptFlush();
return client.getBinaryBulkReply();
return client.getStatusCodeReply();
}
public List<Long> scriptExists(byte[]... sha1) {
client.scriptExists(sha1);
return client.getIntegerMultiBulkReply();
return client.getIntegerMultiBulkReply();
}
public byte[] scriptLoad(byte[] script) {
@@ -3173,17 +3240,17 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getBinaryBulkReply();
}
public byte[] scriptKill() {
public String scriptKill() {
client.scriptKill();
return client.getBinaryBulkReply();
return client.getStatusCodeReply();
}
public byte[] slowlogReset() {
public String slowlogReset() {
client.slowlogReset();
return client.getBinaryBulkReply();
return client.getBulkReply();
}
public long slowlogLen() {
public Long slowlogLen() {
client.slowlogLen();
return client.getIntegerReply();
}
@@ -3212,4 +3279,19 @@ public class BinaryJedis implements BinaryJedisCommands {
client.objectIdletime(key);
return client.getIntegerReply();
}
public Long bitcount(final byte[] key) {
client.bitcount(key);
return client.getIntegerReply();
}
public Long bitcount(final byte[] key, long start, long end) {
client.bitcount(key, start, end);
return client.getIntegerReply();
}
public Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys) {
client.bitop(op, destKey, srcKeys);
return client.getIntegerReply();
}
}

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

@@ -17,6 +17,8 @@ public interface BinaryJedisCommands {
Boolean exists(byte[] key);
Long persist(byte[] key);
String type(byte[] key);
Long expire(byte[] key, int seconds);
@@ -25,6 +27,16 @@ public interface BinaryJedisCommands {
Long ttl(byte[] key);
Boolean setbit(byte[] key, long offset, boolean value);
Boolean setbit(byte[] key, long offset, byte[] value);
Boolean getbit(byte[] key, long offset);
Long setrange(byte[] key, long offset, byte[] value);
byte[] getrange(byte[] key, long startOffset, long endOffset);
byte[] getSet(byte[] key, byte[] value);
Long setnx(byte[] key, byte[] value);
@@ -71,21 +83,21 @@ public interface BinaryJedisCommands {
Map<byte[], byte[]> hgetAll(byte[] key);
Long rpush(byte[] key, byte[]... string);
Long rpush(byte[] key, byte[]... args);
Long lpush(byte[] key, byte[]... string);
Long lpush(byte[] key, byte[]... args);
Long llen(byte[] key);
List<byte[]> lrange(byte[] key, int start, int end);
List<byte[]> lrange(byte[] key, long start, long end);
String ltrim(byte[] key, int start, int end);
String ltrim(byte[] key, long start, long end);
byte[] lindex(byte[] key, int index);
byte[] lindex(byte[] key, long index);
String lset(byte[] key, int index, byte[] value);
String lset(byte[] key, long index, byte[] value);
Long lrem(byte[] key, int count, byte[] value);
Long lrem(byte[] key, long count, byte[] value);
byte[] lpop(byte[] key);
@@ -105,11 +117,13 @@ public interface BinaryJedisCommands {
byte[] srandmember(byte[] key);
Long zadd(byte[] key, double score, byte[] member);
Long strlen(byte[] key);
Long zadd(byte[] key, double score, byte[] member);
Long zadd(byte[] key, Map<Double, byte[]> scoreMembers);
Set<byte[]> zrange(byte[] key, int start, int end);
Set<byte[]> zrange(byte[] key, long start, long end);
Long zrem(byte[] key, byte[]... member);
@@ -119,11 +133,11 @@ public interface BinaryJedisCommands {
Long zrevrank(byte[] key, byte[] member);
Set<byte[]> zrevrange(byte[] key, int start, int end);
Set<byte[]> zrevrange(byte[] key, long start, long end);
Set<Tuple> zrangeWithScores(byte[] key, int start, int end);
Set<Tuple> zrangeWithScores(byte[] key, long start, long end);
Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end);
Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end);
Long zcard(byte[] key);
@@ -139,54 +153,68 @@ public interface BinaryJedisCommands {
Set<byte[]> zrangeByScore(byte[] key, double min, double max);
Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset,
int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max);
Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max,
int offset, int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
int offset, int count);
Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max);
Set<byte[]> zrevrangeByScore(byte[] key, double max, double min);
Set<byte[]> zrevrangeByScore(byte[] key, double max, double min,
int offset, int count);
Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset,
int count);
Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min);
Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min,
int offset, int count);
Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset,
int count);
Set<byte[]> zrevrangeByScore(byte[] key, double max, double min,
int offset, int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min,
int offset, int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max,
int offset, int count);
Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min,
int offset, int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min,
int offset, int count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
int offset, int count);
Long zremrangeByRank(byte[] key, int start, int end);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min,
int offset, int count);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min,
int offset, int count);
Long zremrangeByRank(byte[] key, long start, long end);
Long zremrangeByScore(byte[] key, double start, double end);
Long zremrangeByScore(byte[] key, byte[] start, byte[] end);
Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value);
Long linsert(byte[] key, Client.LIST_POSITION where, byte[] pivot,
byte[] value);
Long lpushx(byte[] key, byte[]... arg);
Long rpushx(byte[] key, byte[]... arg);
Long objectRefcount(byte[] key);
List<byte[]> blpop(byte[] arg);
Long objectIdletime(byte[] key);
List<byte[]> brpop(byte[] arg);
byte[] objectEncoding(byte[] key);
Long del(byte[] key);
Long lpushx(byte[] key, byte[] string);
byte[] echo(byte[] arg);
Long rpushx(byte[] key, byte[] string);
Long move(byte[] key, int dbIndex);
Long bitcount(final byte[] key);
Long bitcount(final byte[] key, long start, long end);
}

219
src/main/java/redis/clients/jedis/BinaryRedisPipeline.java Normal file
View File

@@ -0,0 +1,219 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author guy
*/
public interface BinaryRedisPipeline {
Response<Long> append(byte[] key, byte[] value);
Response<List<byte[]>> blpop(byte[] arg);
Response<List<byte[]>> brpop(byte[] arg);
Response<Long> decr(byte[] key);
Response<Long> decrBy(byte[] key, long integer);
Response<Long> del(byte[] keys);
Response<byte[]> echo(byte[] string);
Response<Boolean> exists(byte[] key);
Response<Long> expire(byte[] key, int seconds);
Response<Long> expireAt(byte[] key, long unixTime);
Response<byte[]> get(byte[] key);
Response<Boolean> getbit(byte[] key, long offset);
Response<byte[]> getSet(byte[] key, byte[] value);
Response<Long> getrange(byte[] key, long startOffset, long endOffset);
Response<Long> hdel(byte[] key, byte[] field);
Response<Boolean> hexists(byte[] key, byte[] field);
Response<byte[]> hget(byte[] key, byte[] field);
Response<Map<byte[], byte[]>> hgetAll(byte[] key);
Response<Long> hincrBy(byte[] key, byte[] field, long value);
Response<Set<byte[]>> hkeys(byte[] key);
Response<Long> hlen(byte[] key);
Response<List<byte[]>> hmget(byte[] key, byte[]... fields);
Response<String> hmset(byte[] key, Map<byte[], byte[]> hash);
Response<Long> hset(byte[] key, byte[] field, byte[] value);
Response<Long> hsetnx(byte[] key, byte[] field, byte[] value);
Response<List<byte[]>> hvals(byte[] key);
Response<Long> incr(byte[] key);
Response<Long> incrBy(byte[] key, long integer);
Response<byte[]> lindex(byte[] key, int index);
Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
byte[] pivot, byte[] value);
Response<Long> llen(byte[] key);
Response<byte[]> lpop(byte[] key);
Response<Long> lpush(byte[] key, byte[]... string);
Response<Long> lpushx(byte[] key, byte[]... bytes);
Response<List<byte[]>> lrange(byte[] key, long start, long end);
Response<Long> lrem(byte[] key, long count, byte[] value);
Response<String> lset(byte[] key, long index, byte[] value);
Response<String> ltrim(byte[] key, long start, long end);
Response<Long> move(byte[] key, int dbIndex);
Response<Long> persist(byte[] key);
Response<byte[]> rpop(byte[] key);
Response<Long> rpush(byte[] key, byte[]... string);
Response<Long> rpushx(byte[] key, byte[]... string);
Response<Long> sadd(byte[] key, byte[]... member);
Response<Long> scard(byte[] key);
Response<String> set(byte[] key, byte[] value);
Response<Boolean> setbit(byte[] key, long offset, byte[] value);
Response<Long> setrange(byte[] key, long offset, byte[] value);
Response<String> setex(byte[] key, int seconds, byte[] value);
Response<Long> setnx(byte[] key, byte[] value);
Response<Long> setrange(String key, long offset, String value);
Response<Set<byte[]>> smembers(byte[] key);
Response<Boolean> sismember(byte[] key, byte[] member);
Response<List<byte[]>> sort(byte[] key);
Response<List<byte[]>> sort(byte[] key,
SortingParams sortingParameters);
Response<byte[]> spop(byte[] key);
Response<byte[]> srandmember(byte[] key);
Response<Long> srem(byte[] key, byte[] member);
Response<Long> strlen(byte[] key);
Response<String> substr(byte[] key, int start, int end);
Response<Long> ttl(byte[] key);
Response<String> type(byte[] key);
Response<Long> zadd(byte[] key, double score, byte[] member);
Response<Long> zcard(byte[] key);
Response<Long> zcount(byte[] key, double min, double max);
Response<Double> zincrby(byte[] key, double score, byte[] member);
Response<Set<byte[]>> zrange(byte[] key, int start, int end);
Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max);
Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max);
Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max, int offset, int count);
Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max, int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max, int offset, int count);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
double min);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
byte[] min);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
double min, int offset, int count);
Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
byte[] min, int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
double max, double min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
byte[] max, byte[] min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
double max, double min, int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
byte[] max, byte[] min, int offset, int count);
Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end);
Response<Long> zrank(byte[] key, byte[] member);
Response<Long> zrem(byte[] key, byte[] member);
Response<Long> zremrangeByRank(byte[] key, int start, int end);
Response<Long> zremrangeByScore(byte[] key, double start, double end);
Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end);
Response<Set<byte[]>> zrevrange(byte[] key, int start, int end);
Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
int end);
Response<Long> zrevrank(byte[] key, byte[] member);
Response<Double> zscore(byte[] key, byte[] member);
Response<Long> bitcount(byte[] key);
Response<Long> bitcount(byte[] key, long start, long end);
}

30
src/main/java/redis/clients/jedis/BinaryScriptingCommands.java Normal file
View File

@@ -0,0 +1,30 @@
package redis.clients.jedis;
import java.util.List;
public interface BinaryScriptingCommands {
Object eval(byte[] script, byte[] 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);
Object evalsha(byte[] script);
Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args);
Object evalsha(byte[] sha1, int keyCount, byte[]... params);
// TODO: should be Boolean, add singular version
List<Long> scriptExists(byte[]... sha1);
byte[] scriptLoad(byte[] script);
String scriptFlush();
String scriptKill();
}

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

@@ -1,5 +1,9 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import redis.clients.util.Sharded;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
@@ -7,10 +11,6 @@ import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import redis.clients.util.Sharded;
public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
implements BinaryJedisCommands {
public BinaryShardedJedis(List<JedisShardInfo> shards) {
@@ -30,10 +30,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
super(shards, algo, keyTagPattern);
}
public void disconnect() throws IOException {
for (Jedis jedis : getAllShards()) {
jedis.disconnect();
}
public void disconnect() {
for (Jedis jedis : getAllShards()) {
jedis.quit();
jedis.disconnect();
}
}
protected Jedis create(JedisShardInfo shard) {
@@ -205,13 +206,22 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.lpush(key, strings);
}
public Long lpushx(byte[] key, byte[] string) {
public Long strlen(final byte[] key) {
Jedis j = getShard(key);
return j.strlen(key);
}
public Long lpushx(byte[] key, byte[]... string) {
Jedis j = getShard(key);
return j.lpushx(key, string);
}
public Long rpushx(byte[] key, byte[] string) {
public Long persist(final byte[] key) {
Jedis j = getShard(key);
return j.persist(key);
}
public Long rpushx(byte[] key, byte[]... string) {
Jedis j = getShard(key);
return j.rpushx(key, string);
}
@@ -221,27 +231,27 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.llen(key);
}
public List<byte[]> lrange(byte[] key, int start, int end) {
public List<byte[]> lrange(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.lrange(key, start, end);
}
public String ltrim(byte[] key, int start, int end) {
public String ltrim(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.ltrim(key, start, end);
}
public byte[] lindex(byte[] key, int index) {
public byte[] lindex(byte[] key, long index) {
Jedis j = getShard(key);
return j.lindex(key, index);
}
public String lset(byte[] key, int index, byte[] value) {
public String lset(byte[] key, long index, byte[] value) {
Jedis j = getShard(key);
return j.lset(key, index, value);
}
public Long lrem(byte[] key, int count, byte[] value) {
public Long lrem(byte[] key, long count, byte[] value) {
Jedis j = getShard(key);
return j.lrem(key, count, value);
}
@@ -301,7 +311,7 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.zadd(key, scoreMembers);
}
public Set<byte[]> zrange(byte[] key, int start, int end) {
public Set<byte[]> zrange(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.zrange(key, start, end);
}
@@ -326,17 +336,17 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.zrevrank(key, member);
}
public Set<byte[]> zrevrange(byte[] key, int start, int end) {
public Set<byte[]> zrevrange(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.zrevrange(key, start, end);
}
public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
public Set<Tuple> zrangeWithScores(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end);
}
public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
public Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end);
}
@@ -392,7 +402,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count);
}
public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max);
}
public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
Jedis j = getShard(key);
@@ -405,6 +419,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.zrangeByScoreWithScores(key, min, max, offset, count);
}
public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count);
}
public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min);
@@ -451,7 +470,7 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
}
public Long zremrangeByRank(byte[] key, int start, int end) {
public Long zremrangeByRank(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end);
}
@@ -499,4 +518,59 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
Jedis j = getShard(key);
return j.objectIdletime(key);
}
public Boolean setbit(byte[] key, long offset, boolean value) {
Jedis j = getShard(key);
return j.setbit(key, offset, value);
}
public Boolean setbit(byte[] key, long offset, byte[] value) {
Jedis j = getShard(key);
return j.setbit(key, offset, value);
}
public Boolean getbit(byte[] key, long offset) {
Jedis j = getShard(key);
return j.getbit(key, offset);
}
public Long setrange(byte[] key, long offset, byte[] value) {
Jedis j = getShard(key);
return j.setrange(key, offset, value);
}
public byte[] getrange(byte[] key, long startOffset, long endOffset) {
Jedis j = getShard(key);
return j.getrange(key, startOffset, endOffset);
}
public Long move(byte[] key, int dbIndex) {
Jedis j = getShard(key);
return j.move(key, dbIndex);
}
public byte[] echo(byte[] arg) {
Jedis j = getShard(arg);
return j.echo(arg);
}
public List<byte[]> brpop(byte[] arg) {
Jedis j = getShard(arg);
return j.brpop(arg);
}
public List<byte[]> blpop(byte[] arg) {
Jedis j = getShard(arg);
return j.blpop(arg);
}
public Long bitcount(byte[] key) {
Jedis j = getShard(key);
return j.bitcount(key);
}
public Long bitcount(byte[] key, long start, long end) {
Jedis j = getShard(key);
return j.bitcount(key, start, end);
}
}

675
src/main/java/redis/clients/jedis/BinaryTransaction.java
View File

@@ -1,675 +0,0 @@
package redis.clients.jedis;
import static redis.clients.jedis.Protocol.toByteArray;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.exceptions.JedisDataException;
public class BinaryTransaction extends Queable {
protected Client client = null;
protected boolean inTransaction = true;
public BinaryTransaction() {
}
public BinaryTransaction(final Client client) {
this.client = client;
}
public List<Object> exec() {
client.exec();
client.getAll(1); // Discard all but the last reply
List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) {
return null;
}
List<Object> formatted = new ArrayList<Object>();
for (Object o : unformatted) {
try{
formatted.add(generateResponse(o).get());
}catch(JedisDataException e){
formatted.add(e);
}
}
return formatted;
}
public List<Response<?>> execGetResponse() {
client.exec();
client.getAll(1); // Discard all but the last reply
List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) {
return null;
}
List<Response<?>> response = new ArrayList<Response<?>>();
for (Object o : unformatted) {
response.add(generateResponse(o));
}
return response;
}
public String discard() {
client.discard();
client.getAll(1); // Discard all but the last reply
inTransaction = false;
clean();
return client.getStatusCodeReply();
}
public Response<Long> append(byte[] key, byte[] value) {
client.append(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> blpop(byte[]... args) {
client.blpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> brpop(byte[]... args) {
client.brpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> decr(byte[] key) {
client.decr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decrBy(byte[] key, long integer) {
client.decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> del(byte[]... keys) {
client.del(keys);
return getResponse(BuilderFactory.LONG);
}
public Response<String> echo(byte[] string) {
client.echo(string);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> exists(byte[] key) {
client.exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> expire(byte[] key, int seconds) {
client.expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(byte[] key, long unixTime) {
client.expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public Response<byte[]> get(byte[] key) {
client.get(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<String> getSet(byte[] key, byte[] value) {
client.getSet(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hdel(byte[] key, byte[] field) {
client.hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> hexists(byte[] key, byte[] field) {
client.hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<byte[]> hget(byte[] key, byte[] field) {
client.hget(key, field);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Map<String, String>> hgetAll(byte[] key) {
client.hgetAll(key);
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
client.hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> hkeys(byte[] key) {
client.hkeys(key);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> hlen(byte[] key) {
client.hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
client.hmget(key, fields);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<byte[]> hmset(byte[] key, Map<byte[], byte[]> hash) {
client.hmset(key, hash);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
client.hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
client.hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<byte[]>> hvals(byte[] key) {
client.hvals(key);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> incr(byte[] key) {
client.incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(byte[] key, long integer) {
client.incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> keys(byte[] pattern) {
client.keys(pattern);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<byte[]> lindex(byte[] key, long index) {
client.lindex(key, index);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> linsert(byte[] key, LIST_POSITION where,
byte[] pivot, byte[] value) {
client.linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(byte[] key) {
client.llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<byte[]> lpop(byte[] key) {
client.lpop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> lpush(byte[] key, byte[] string) {
client.lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(byte[] key, byte[] bytes) {
client.lpushx(key, bytes);
return getResponse(BuilderFactory.LONG);
}
public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
client.lrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> lrem(byte[] key, long count, byte[] value) {
client.lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lset(byte[] key, long index, byte[] value) {
client.lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(byte[] key, long start, long end) {
client.ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<List<byte[]>> mget(byte[]... keys) {
client.mget(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> move(byte[] key, int dbIndex) {
client.move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<String> mset(byte[]... keysvalues) {
client.mset(keysvalues);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> msetnx(byte[]... keysvalues) {
client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(byte[] key) {
client.persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rename(byte[] oldkey, byte[] newkey) {
client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG);
}
public Response<byte[]> rpop(byte[] key) {
client.rpop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> rpush(byte[] key, byte[] string) {
client.rpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpushx(byte[] key, byte[] string) {
client.rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(byte[] key, byte[] member) {
client.sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(byte[] key) {
client.scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> sdiff(byte[]... keys) {
client.sdiff(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<byte[]> set(byte[] key, byte[] value) {
client.set(key, value);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Boolean> setbit(String key, long offset, boolean value) {
client.setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> setex(byte[] key, int seconds, byte[] value) {
client.setex(key, seconds, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> setnx(byte[] key, byte[] value) {
client.setnx(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> sinter(byte[]... keys) {
client.sinter(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(byte[] key, byte[] member) {
client.sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Set<byte[]>> smembers(byte[] key) {
client.smembers(key);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG);
}
public Response<List<byte[]>> sort(byte[] key) {
client.sort(key);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<List<byte[]>> sort(byte[] key,
SortingParams sortingParameters) {
client.sort(key, sortingParameters);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<List<byte[]>> sort(byte[] key,
SortingParams sortingParameters, byte[] dstkey) {
client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<List<byte[]>> sort(byte[] key, byte[] dstkey) {
client.sort(key, dstkey);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<byte[]> spop(byte[] key) {
client.spop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<byte[]> srandmember(byte[] key) {
client.srandmember(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> srem(byte[] key, byte[] member) {
client.srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(byte[] key) {
client.strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(byte[] key, int start, int end) { // what's
// that?
client.substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Set<byte[]>> sunion(byte[]... keys) {
client.sunion(keys);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(byte[] key) {
client.ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> type(byte[] key) {
client.type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(byte[] key, double score, byte[] member) {
client.zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(byte[] key) {
client.zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(byte[] key, double min, double max) {
return zcount(key, toByteArray(min), toByteArray(max));
}
public Response<Long> zcount(byte[] key, byte[] min, byte[] max) {
client.zcount(key, min, max);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(byte[] key, double score, byte[] member) {
client.zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zinterstore(byte[] dstkey, ZParams params,
byte[]... sets) {
client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
client.zrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max) {
return zrangeByScore(key, toByteArray(min), toByteArray(max));
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max, int offset, int count) {
client.zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max, int offset, int count) {
return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max) {
return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count) {
return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max) {
client.zrangeByScoreWithScores(key, min, max);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max, int offset, int count) {
client.zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
client.zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Long> zrank(byte[] key, byte[] member) {
client.zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(byte[] key, byte[] member) {
client.zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
client.zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
return zremrangeByScore(key, toByteArray(start), toByteArray(end));
}
public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
client.zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
client.zrevrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
int end) {
client.zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Long> zrevrank(byte[] key, byte[] member) {
client.zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(byte[] key, byte[] member) {
client.zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zunionstore(byte[] dstkey, ZParams params,
byte[]... sets) {
client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
int timeout) {
client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<String> select(final int index) {
client.select(index);
return getResponse(BuilderFactory.STRING);
}
public Response<String> flushDB() {
client.flushDB();
return getResponse(BuilderFactory.STRING);
}
public Response<String> flushAll() {
client.flushAll();
return getResponse(BuilderFactory.STRING);
}
public Response<String> save() {
client.save();
return getResponse(BuilderFactory.STRING);
}
public Response<String> info() {
client.info();
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lastsave() {
client.lastsave();
return getResponse(BuilderFactory.LONG);
}
public Response<Long> dbSize() {
client.dbSize();
return getResponse(BuilderFactory.LONG);
}
public Response<List<byte[]>> configGet(final byte[] pattern) {
client.configGet(pattern);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<byte[]> configSet(final byte[] parameter, final byte[] value) {
client.configSet(parameter, value);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<String> configResetStat() {
client.configResetStat();
return getResponse(BuilderFactory.STRING);
}
public Response<String> shutdown() {
client.shutdown();
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> getbit(final byte[] key, final long offset) {
client.getbit(key, offset);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> setbit(final byte[] key, final long offset, final byte[] value) {
client.setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> ping() {
client.ping();
return getResponse(BuilderFactory.STRING);
}
public Response<Long> setrange(byte[] key, long offset, byte[] value) {
client.setrange(key, offset, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> randomKey() {
client.randomKey();
return getResponse(BuilderFactory.STRING);
}
public Response<Long> publish(byte[] channel, byte[] message) {
client.publish(channel, message);
return getResponse(BuilderFactory.LONG);
}
}

8
src/main/java/redis/clients/jedis/BitOP.java Normal file
View File

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

25
src/main/java/redis/clients/jedis/BuilderFactory.java Normal file → Executable file
View File

@@ -144,6 +144,13 @@ public class BuilderFactory {
}
List<byte[]> l = (List<byte[]>) data;
final Set<byte[]> result = new LinkedHashSet<byte[]>(l);
for (final byte[] barray : l) {
if (barray == null) {
result.add(null);
} else {
result.add(barray);
}
}
return result;
}
@@ -151,6 +158,24 @@ public class BuilderFactory {
return "ZSet<byte[]>";
}
};
public static final Builder<Map<byte[], byte[]>> BYTE_ARRAY_MAP = new Builder<Map<byte[], byte[]>>() {
@SuppressWarnings("unchecked")
public Map<byte[], byte[]> build(Object data) {
final List<byte[]> flatHash = (List<byte[]>) data;
final Map<byte[], byte[]> hash = new HashMap<byte[], byte[]>();
final Iterator<byte[]> iterator = flatHash.iterator();
while (iterator.hasNext()) {
hash.put(iterator.next(), iterator.next());
}
return hash;
}
public String toString() {
return "Map<byte[], byte[]>";
}
};
public static final Builder<Set<String>> STRING_ZSET = new Builder<Set<String>>() {
@SuppressWarnings("unchecked")

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

@@ -572,16 +572,16 @@ public class Client extends BinaryClient implements Commands {
strlen(SafeEncoder.encode(key));
}
public void lpushx(final String key, final String string) {
lpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
public void lpushx(final String key, final String... string) {
lpushx(SafeEncoder.encode(key), getByteParams(string));
}
public void persist(final String key) {
persist(SafeEncoder.encode(key));
}
public void rpushx(final String key, final String string) {
rpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
public void rpushx(final String key, final String... string) {
rpushx(SafeEncoder.encode(key), getByteParams(string));
}
public void echo(final String string) {
@@ -600,7 +600,11 @@ public class Client extends BinaryClient implements Commands {
}
public void setbit(final String key, final long offset, final boolean value) {
setbit(SafeEncoder.encode(key), offset, toByteArray(value ? 1 : 0));
setbit(SafeEncoder.encode(key), offset, value);
}
public void setbit(final String key, final long offset, final String value) {
setbit(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
}
public void getbit(String key, long offset) {
@@ -711,4 +715,29 @@ public class Client extends BinaryClient implements Commands {
public void objectEncoding(String key) {
objectEncoding(SafeEncoder.encode(key));
}
public void bitcount(final String key) {
bitcount(SafeEncoder.encode(key));
}
public void bitcount(final String key, long start, long end) {
bitcount(SafeEncoder.encode(key), start, end);
}
public void bitop(BitOP op, final String destKey, String... srcKeys) {
bitop(op, SafeEncoder.encode(destKey), getByteParams(srcKeys));
}
public void sentinel(final String... args) {
final byte[][] arg = new byte[args.length][];
for (int i = 0; i < arg.length; i++) {
arg[i] = SafeEncoder.encode(args[i]);
}
sentinel(arg);
}
public void sentinel(final String cmd, String arg1, int arg2) {
sentinel(SafeEncoder.encode(cmd), SafeEncoder.encode(arg1),
toByteArray(arg2));
}
}

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

@@ -30,6 +30,8 @@ public interface Commands {
public void setbit(String key, long offset, boolean value);
public void setbit(String key, long offset, String value);
public void getbit(String key, long offset);
public void setrange(String key, long offset, String value);
@@ -253,11 +255,11 @@ public interface Commands {
public void strlen(final String key);
public void lpushx(final String key, final String string);
public void lpushx(final String key, final String... string);
public void persist(final String key);
public void rpushx(final String key, final String string);
public void rpushx(final String key, final String... string);
public void echo(final String string);
@@ -289,4 +291,10 @@ public interface Commands {
public void objectIdletime(String key);
public void objectEncoding(String key);
}
public void bitcount(final String key);
public void bitcount(final String key, long start, long end);
public void bitop(BitOP op, final String destKey, String... srcKeys);
}

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

@@ -2,6 +2,7 @@ package redis.clients.jedis;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
@@ -13,7 +14,7 @@ import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.SafeEncoder;
import redis.clients.util.Slowlog;
public class Jedis extends BinaryJedis implements JedisCommands {
public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands {
public Jedis(final String host) {
super(host);
}
@@ -34,12 +35,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
super(uri);
}
public String ping() {
checkIsInMulti();
client.ping();
return client.getStatusCodeReply();
}
/**
* Set the string value as value of the key. The string can't be longer than
* 1073741824 bytes (1 GB).
@@ -72,16 +67,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getBulkReply();
}
/**
* Ask the server to silently close the connection.
*/
public String quit() {
checkIsInMulti();
client.quit();
return client.getStatusCodeReply();
}
/**
* Test if the specified key exists. The command returns "1" if the key
* exists, otherwise "0" is returned. Note that even keys set with an empty
@@ -114,6 +99,11 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
public Long del(String key) {
client.del(key);
return client.getIntegerReply();
}
/**
* Return the type of the value stored at key in form of a string. The type
* can be one of "none", "string", "list", "set". "none" is returned if the
@@ -134,19 +124,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getStatusCodeReply();
}
/**
* Delete all the keys of the currently selected DB. This command never
* fails.
*
* @return Status code reply
*/
public String flushDB() {
checkIsInMulti();
client.flushDB();
return client.getStatusCodeReply();
}
/**
* Returns all the keys matching the glob-style pattern as space separated
* strings. For example if you have in the database the keys "foo" and
@@ -320,20 +297,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
/**
* Select the DB with having the specified zero-based numeric index. For
* default every new client connection is automatically selected to DB 0.
*
* @param index
* @return Status code reply
*/
public String select(final int index) {
checkIsInMulti();
client.select(index);
return client.getStatusCodeReply();
}
/**
* Move the specified key from the currently selected DB to the specified
* destination DB. Note that this command returns 1 only if the key was
@@ -353,19 +316,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
/**
* Delete all the keys of all the existing databases, not just the currently
* selected one. This command never fails.
*
* @return Status code reply
*/
public String flushAll() {
checkIsInMulti();
client.flushAll();
return client.getStatusCodeReply();
}
/**
* GETSET is an atomic set this value and return the old value command. Set
* key to the string value and return the old value stored at key. The
@@ -916,8 +866,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* <p>
* Time complexity: O(1)
*
* @see Jedis#lpush(String, String)
*
* @param key
* @param strings
* @return Integer reply, specifically, the number of elements inside the
@@ -937,8 +885,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* <p>
* Time complexity: O(1)
*
* @see Jedis#rpush(String, String)
*
* @param key
* @param strings
* @return Integer reply, specifically, the number of elements inside the
@@ -1868,6 +1814,42 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return multiBulkReply;
}
public List<String> blpop(String... args) {
client.blpop(args);
client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<String> brpop(String... args) {
client.brpop(args);
client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<String> blpop(String arg) {
String[] args = new String[1];
args[0] = arg;
client.blpop(args);
client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
public List<String> brpop(String arg) {
String[] args = new String[1];
args[0] = arg;
client.brpop(args);
client.setTimeoutInfinite();
final List<String> multiBulkReply = client.getMultiBulkReply();
client.rollbackTimeout();
return multiBulkReply;
}
/**
* Sort a Set or a List accordingly to the specified parameters and store
* the result at dstkey.
@@ -1998,49 +1980,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return multiBulkReply;
}
/**
* Request for authentication in a password protected Redis server. A Redis
* server can be instructed to require a password before to allow clients to
* issue commands. This is done using the requirepass directive in the Redis
* configuration file. If the password given by the client is correct the
* server replies with an OK status code reply and starts accepting commands
* from the client. Otherwise an error is returned and the clients needs to
* try a new password. Note that for the high performance nature of Redis it
* is possible to try a lot of passwords in parallel in very short time, so
* make sure to generate a strong and very long password so that this attack
* is infeasible.
*
* @param password
* @return Status code reply
*/
public String auth(final String password) {
checkIsInMulti();
client.auth(password);
return client.getStatusCodeReply();
}
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
checkIsInMulti();
connect();
client.setTimeoutInfinite();
jedisPubSub.proceed(client, channels);
client.rollbackTimeout();
}
public Long publish(String channel, String message) {
checkIsInMulti();
client.publish(channel, message);
return client.getIntegerReply();
}
public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
checkIsInMulti();
connect();
client.setTimeoutInfinite();
jedisPubSub.proceedWithPatterns(client, patterns);
client.rollbackTimeout();
}
public Long zcount(final String key, final double min, final double max) {
checkIsInMulti();
@@ -2647,7 +2587,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
public Long lpushx(final String key, final String string) {
public Long lpushx(final String key, final String... string) {
client.lpushx(key, string);
return client.getIntegerReply();
}
@@ -2667,7 +2607,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
public Long rpushx(final String key, final String string) {
public Long rpushx(final String key, final String... string) {
client.rpushx(key, string);
return client.getIntegerReply();
}
@@ -2713,6 +2653,11 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply() == 1;
}
public Boolean setbit(String key, long offset, String value) {
client.setbit(key, offset, value);
return client.getIntegerReply() == 1;
}
/**
* Returns the bit value at offset in the string value stored at key
*
@@ -2822,6 +2767,29 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return getEvalResult();
}
public void subscribe(final JedisPubSub jedisPubSub,
final String... channels) {
client.setTimeoutInfinite();
jedisPubSub.proceed(client, channels);
client.rollbackTimeout();
}
public Long publish(final String channel, final String message) {
checkIsInMulti();
connect();
client.publish(channel, message);
return client.getIntegerReply();
}
public void psubscribe(final JedisPubSub jedisPubSub,
final String... patterns) {
checkIsInMulti();
connect();
client.setTimeoutInfinite();
jedisPubSub.proceedWithPatterns(client, patterns);
client.rollbackTimeout();
}
private String[] getParams(List<String> keys, List<String> args) {
int keyCount = keys.size();
int argCount = args.size();
@@ -2851,15 +2819,17 @@ public class Jedis extends BinaryJedis implements JedisCommands {
private Object getEvalResult() {
Object result = client.getOne();
if (result instanceof byte[])
return SafeEncoder.encode((byte[]) result);
if (result instanceof List<?>) {
List<?> list = (List<?>) result;
List<String> listResult = new ArrayList<String>(list.size());
for (Object bin : list)
listResult.add(SafeEncoder.encode((byte[]) bin));
for (Object bin : list) {
listResult.add((bin == null ? null : SafeEncoder
.encode((byte[]) bin)));
}
return listResult;
}
@@ -2924,4 +2894,159 @@ public class Jedis extends BinaryJedis implements JedisCommands {
client.objectIdletime(string);
return client.getIntegerReply();
}
public Long bitcount(final String key) {
client.bitcount(key);
return client.getIntegerReply();
}
public Long bitcount(final String key, long start, long end) {
client.bitcount(key, start, end);
return client.getIntegerReply();
}
public Long bitop(BitOP op, final String destKey, String... srcKeys) {
client.bitop(op, destKey, srcKeys);
return client.getIntegerReply();
}
/**
* <pre>
* redis 127.0.0.1:26381> sentinel masters
* 1) 1) "name"
* 2) "mymaster"
* 3) "ip"
* 4) "127.0.0.1"
* 5) "port"
* 6) "6379"
* 7) "runid"
* 8) "93d4d4e6e9c06d0eea36e27f31924ac26576081d"
* 9) "flags"
* 10) "master"
* 11) "pending-commands"
* 12) "0"
* 13) "last-ok-ping-reply"
* 14) "423"
* 15) "last-ping-reply"
* 16) "423"
* 17) "info-refresh"
* 18) "6107"
* 19) "num-slaves"
* 20) "1"
* 21) "num-other-sentinels"
* 22) "2"
* 23) "quorum"
* 24) "2"
*
* </pre>
*
* @return
*/
public List<Map<String, String>> sentinelMasters() {
client.sentinel(Protocol.SENTINEL_MASTERS);
final List<Object> reply = client.getObjectMultiBulkReply();
final List<Map<String, String>> masters = new ArrayList<Map<String, String>>();
for (Object obj : reply) {
masters.add(BuilderFactory.STRING_MAP.build((List) obj));
}
return masters;
}
/**
* <pre>
* redis 127.0.0.1:26381> sentinel get-master-addr-by-name mymaster
* 1) "127.0.0.1"
* 2) "6379"
* </pre>
*
* @param masterName
* @return two elements list of strings : host and port.
*/
public List<String> sentinelGetMasterAddrByName(String masterName) {
client.sentinel(Protocol.SENTINEL_GET_MASTER_ADDR_BY_NAME, masterName);
final List<Object> reply = client.getObjectMultiBulkReply();
return BuilderFactory.STRING_LIST.build(reply);
}
/**
* <pre>
* redis 127.0.0.1:26381> sentinel reset mymaster
* (integer) 1
* </pre>
*
* @param pattern
* @return
*/
public Long sentinelReset(String pattern) {
client.sentinel(Protocol.SENTINEL_RESET, pattern);
return client.getIntegerReply();
}
/**
* <pre>
* redis 127.0.0.1:26381> sentinel slaves mymaster
* 1) 1) "name"
* 2) "127.0.0.1:6380"
* 3) "ip"
* 4) "127.0.0.1"
* 5) "port"
* 6) "6380"
* 7) "runid"
* 8) "d7f6c0ca7572df9d2f33713df0dbf8c72da7c039"
* 9) "flags"
* 10) "slave"
* 11) "pending-commands"
* 12) "0"
* 13) "last-ok-ping-reply"
* 14) "47"
* 15) "last-ping-reply"
* 16) "47"
* 17) "info-refresh"
* 18) "657"
* 19) "master-link-down-time"
* 20) "0"
* 21) "master-link-status"
* 22) "ok"
* 23) "master-host"
* 24) "localhost"
* 25) "master-port"
* 26) "6379"
* 27) "slave-priority"
* 28) "100"
* </pre>
*
* @param masterName
* @return
*/
public List<Map<String, String>> sentinelSlaves(String masterName) {
client.sentinel(Protocol.SENTINEL_SLAVES, masterName);
final List<Object> reply = client.getObjectMultiBulkReply();
final List<Map<String, String>> slaves = new ArrayList<Map<String, String>>();
for (Object obj : reply) {
slaves.add(BuilderFactory.STRING_MAP.build((List) obj));
}
return slaves;
}
/**
* <pre>
* redis 127.0.0.1:26381> SENTINEL is-master-down-by-addr 127.0.0.1 1
* 1) (integer) 0
* 2) "?"
* redis 127.0.0.1:26381> SENTINEL is-master-down-by-addr 127.0.0.1 6379
* 1) (integer) 0
* 2) "aaef11fbb2712346a386078c7f9834e72ed51e96"
* </pre>
*
* @return Long followed by the String (runid)
*/
public List<? extends Object> sentinelIsMasterDownByAddr(String host,
int port) {
client.sentinel(Protocol.SENTINEL_IS_MASTER_DOWN_BY_ADDR, host, port);
final List<Object> reply = client.getObjectMultiBulkReply();
return Arrays.asList(BuilderFactory.LONG.build(reply.get(0)),
BuilderFactory.STRING.build(reply.get(1)));
}
}

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

@@ -14,6 +14,8 @@ public interface JedisCommands {
Boolean exists(String key);
Long persist(String key);
String type(String key);
Long expire(String key, int seconds);
@@ -24,6 +26,8 @@ public interface JedisCommands {
Boolean setbit(String key, long offset, boolean value);
Boolean setbit(String key, long offset, String value);
Boolean getbit(String key, long offset);
Long setrange(String key, long offset, String value);
@@ -106,6 +110,8 @@ public interface JedisCommands {
String srandmember(String key);
Long strlen(String key);
Long zadd(String key, double score, String member);
Long zadd(String key, Map<Double, String> scoreMembers);
@@ -187,7 +193,21 @@ public interface JedisCommands {
Long linsert(String key, Client.LIST_POSITION where, String pivot,
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> brpop(String arg);
Long del(String key);
String echo(String string);
Long move(String key, int dbIndex);
Long bitcount(final String key);
Long bitcount(final String key, long start, long end);
}

73
src/main/java/redis/clients/jedis/MultiKeyBinaryCommands.java Normal file
View File

@@ -0,0 +1,73 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Set;
public interface MultiKeyBinaryCommands {
Long del(byte[]... keys);
List<byte[]> blpop(int timeout, byte[]... keys);
List<byte[]> brpop(int timeout, byte[]... keys);
List<byte[]> blpop(byte[]... args);
List<byte[]> brpop(byte[]... args);
Set<byte[]> keys(byte[] pattern);
List<byte[]> mget(byte[]... keys);
String mset(byte[]... keysvalues);
Long msetnx(byte[]... keysvalues);
String rename(byte[] oldkey, byte[] newkey);
Long renamenx(byte[] oldkey, byte[] newkey);
byte[] rpoplpush(byte[] srckey, byte[] dstkey);
Set<byte[]> sdiff(byte[]... keys);
Long sdiffstore(byte[] dstkey, byte[]... keys);
Set<byte[]> sinter(byte[]... keys);
Long sinterstore(byte[] dstkey, byte[]... keys);
Long smove(byte[] srckey, byte[] dstkey, byte[] member);
Long sort(byte[] key, SortingParams sortingParameters, byte[] dstkey);
Long sort(byte[] key, byte[] dstkey);
Set<byte[]> sunion(byte[]... keys);
Long sunionstore(byte[] dstkey, byte[]... keys);
String watch(byte[]... keys);
String unwatch();
Long zinterstore(byte[] dstkey, byte[]... sets);
Long zinterstore(byte[] dstkey, ZParams params, byte[]... sets);
Long zunionstore(byte[] dstkey, byte[]... sets);
Long zunionstore(byte[] dstkey, ZParams params, byte[]... sets);
byte[] brpoplpush(byte[] source, byte[] destination, int timeout);
Long publish(byte[] channel, byte[] message);
void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels);
void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns);
byte[] randomBinaryKey();
Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys);
}

67
src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java Normal file
View File

@@ -0,0 +1,67 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Set;
/**
* Multikey related commands (these are split out because they are non-shardable)
*/
public interface MultiKeyBinaryRedisPipeline {
Response<Long> del(byte[]... keys);
Response<List<byte[]>> blpop(byte[]... args);
Response<List<byte[]>> brpop(byte[]... args);
Response<Set<byte[]>> keys(byte[] pattern);
Response<List<byte[]>> mget(byte[]... keys);
Response<String> mset(byte[]... keysvalues);
Response<Long> msetnx(byte[]... keysvalues);
Response<String> rename(byte[] oldkey, byte[] newkey);
Response<Long> renamenx(byte[] oldkey, byte[] newkey);
Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey);
Response<Set<byte[]>> sdiff(byte[]... keys);
Response<Long> sdiffstore(byte[] dstkey, byte[]... keys);
Response<Set<byte[]>> sinter(byte[]... keys);
Response<Long> sinterstore(byte[] dstkey, byte[]... keys);
Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member);
Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters, byte[] dstkey);
Response<List<byte[]>> sort(byte[] key, byte[] dstkey);
Response<Set<byte[]>> sunion(byte[]... keys);
Response<Long> sunionstore(byte[] dstkey, byte[]... keys);
Response<String> watch(byte[]... keys);
Response<Long> zinterstore(byte[] dstkey, byte[]... sets);
Response<Long> zinterstore(byte[] dstkey, ZParams params, byte[]... sets);
Response<Long> zunionstore(byte[] dstkey, byte[]... sets);
Response<Long> zunionstore(byte[] dstkey, ZParams params, byte[]... sets);
Response<byte[]> brpoplpush(byte[] source, byte[] destination, int timeout);
Response<Long> publish(byte[] channel, byte[] message);
Response<byte[]> randomKeyBinary();
Response<Long> bitop(BitOP op, final byte[] destKey, byte[]... srcKeys);
}

73
src/main/java/redis/clients/jedis/MultiKeyCommands.java Normal file
View File

@@ -0,0 +1,73 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Set;
public interface MultiKeyCommands {
Long del(String... keys);
List<String> blpop(int timeout, String... keys);
List<String> brpop(int timeout, String... keys);
List<String> blpop(String... args);
List<String> brpop(String... args);
Set<String> keys(String pattern);
List<String> mget(String... keys);
String mset(String... keysvalues);
Long msetnx(String... keysvalues);
String rename(String oldkey, String newkey);
Long renamenx(String oldkey, String newkey);
String rpoplpush(String srckey, String dstkey);
Set<String> sdiff(String... keys);
Long sdiffstore(String dstkey, String... keys);
Set<String> sinter(String... keys);
Long sinterstore(String dstkey, String... keys);
Long smove(String srckey, String dstkey, String member);
Long sort(String key, SortingParams sortingParameters, String dstkey);
Long sort(String key, String dstkey);
Set<String> sunion(String... keys);
Long sunionstore(String dstkey, String... keys);
String watch(String... keys);
String unwatch();
Long zinterstore(String dstkey, String... sets);
Long zinterstore(String dstkey, ZParams params, String... sets);
Long zunionstore(String dstkey, String... sets);
Long zunionstore(String dstkey, ZParams params, String... sets);
String brpoplpush(String source, String destination, int timeout);
Long publish(String channel, String message);
void subscribe(JedisPubSub jedisPubSub, String... channels);
void psubscribe(JedisPubSub jedisPubSub, String... patterns);
String randomKey();
Long bitop(BitOP op, final String destKey, String... srcKeys);
}

67
src/main/java/redis/clients/jedis/MultiKeyCommandsPipeline.java Normal file
View File

@@ -0,0 +1,67 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Set;
/**
* Multikey related commands (these are split out because they are non-shardable)
*/
public interface MultiKeyCommandsPipeline {
Response<Long> del(String... keys);
Response<List<String>> blpop(String... args);
Response<List<String>> brpop(String... args);
Response<Set<String>> keys(String pattern);
Response<List<String>> mget(String... keys);
Response<String> mset(String... keysvalues);
Response<Long> msetnx(String... keysvalues);
Response<String> rename(String oldkey, String newkey);
Response<Long> renamenx(String oldkey, String newkey);
Response<String> rpoplpush(String srckey, String dstkey);
Response<Set<String>> sdiff(String... keys);
Response<Long> sdiffstore(String dstkey, String... keys);
Response<Set<String>> sinter(String... keys);
Response<Long> sinterstore(String dstkey, String... keys);
Response<Long> smove(String srckey, String dstkey, String member);
Response<List<String>> sort(String key, SortingParams sortingParameters, String dstkey);
Response<List<String>> sort(String key, String dstkey);
Response<Set<String>> sunion(String... keys);
Response<Long> sunionstore(String dstkey, String... keys);
Response<String> watch(String... keys);
Response<Long> zinterstore(String dstkey, String... sets);
Response<Long> zinterstore(String dstkey, ZParams params, String... sets);
Response<Long> zunionstore(String dstkey, String... sets);
Response<Long> zunionstore(String dstkey, ZParams params, String... sets);
Response<String> brpoplpush(String source, String destination, int timeout);
Response<Long> publish(String channel, String message);
Response<String> randomKey();
Response<Long> bitop(BitOP op, final String destKey, String... srcKeys);
}

370
src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java Normal file
View File

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

1261
src/main/java/redis/clients/jedis/Pipeline.java Normal file → Executable file
View File

File diff suppressed because it is too large Load Diff

982
src/main/java/redis/clients/jedis/PipelineBase.java Normal file
View File

@@ -0,0 +1,982 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static redis.clients.jedis.Protocol.toByteArray;
abstract class PipelineBase extends Queable implements
BinaryRedisPipeline,
RedisPipeline {
protected abstract Client getClient(String key);
protected abstract Client getClient(byte[] key);
public Response<Long> append(String key, String value) {
getClient(key).append(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> append(byte[] key, byte[] value) {
getClient(key).append(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> blpop(String key) {
String[] temp = new String[1];
temp[0] = key;
getClient(key).blpop(temp);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> brpop(String key) {
String[] temp = new String[1];
temp[0] = key;
getClient(key).brpop(temp);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> blpop(byte[] key) {
byte[][] temp = new byte[1][];
temp[0] = key;
getClient(key).blpop(temp);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<List<byte[]>> brpop(byte[] key) {
byte[][] temp = new byte[1][];
temp[0] = key;
getClient(key).brpop(temp);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> decr(String key) {
getClient(key).decr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decr(byte[] key) {
getClient(key).decr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decrBy(String key, long integer) {
getClient(key).decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decrBy(byte[] key, long integer) {
getClient(key).decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> del(String key) {
getClient(key).del(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> del(byte[] key) {
getClient(key).del(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> echo(String string) {
getClient(string).echo(string);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> echo(byte[] string) {
getClient(string).echo(string);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Boolean> exists(String key) {
getClient(key).exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> exists(byte[] key) {
getClient(key).exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> expire(String key, int seconds) {
getClient(key).expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expire(byte[] key, int seconds) {
getClient(key).expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(String key, long unixTime) {
getClient(key).expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(byte[] key, long unixTime) {
getClient(key).expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public Response<String> get(String key) {
getClient(key).get(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> get(byte[] key) {
getClient(key).get(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Boolean> getbit(String key, long offset) {
getClient(key).getbit(key, offset);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> getbit(byte[] key, long offset) {
getClient(key).getbit(key, offset);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> getrange(String key, long startOffset,
long endOffset) {
getClient(key).getrange(key, startOffset, endOffset);
return getResponse(BuilderFactory.STRING);
}
public Response<String> getSet(String key, String value) {
getClient(key).getSet(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> getSet(byte[] key, byte[] value) {
getClient(key).getSet(key, value);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
getClient(key).getrange(key, startOffset, endOffset);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hdel(String key, String field) {
getClient(key).hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hdel(byte[] key, byte[] field) {
getClient(key).hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> hexists(String key, String field) {
getClient(key).hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> hexists(byte[] key, byte[] field) {
getClient(key).hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> hget(String key, String field) {
getClient(key).hget(key, field);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> hget(byte[] key, byte[] field) {
getClient(key).hget(key, field);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Map<String, String>> hgetAll(String key) {
getClient(key).hgetAll(key);
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Map<byte[], byte[]>> hgetAll(byte[] key) {
getClient(key).hgetAll(key);
return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
}
public Response<Long> hincrBy(String key, String field, long value) {
getClient(key).hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
getClient(key).hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> hincrByFloat(String key, String field, double value) {
getClient(key).hincrByFloat(key, field, value);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Double> hincrByFloat(byte[] key, byte[] field, double value) {
getClient(key).hincrByFloat(key, field, value);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Set<String>> hkeys(String key) {
getClient(key).hkeys(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Set<byte[]>> hkeys(byte[] key) {
getClient(key).hkeys(key);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Long> hlen(String key) {
getClient(key).hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hlen(byte[] key) {
getClient(key).hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hmget(String key, String... fields) {
getClient(key).hmget(key, fields);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
getClient(key).hmget(key, fields);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<String> hmset(String key, Map<String, String> hash) {
getClient(key).hmset(key, hash);
return getResponse(BuilderFactory.STRING);
}
public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
getClient(key).hmset(key, hash);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hset(String key, String field, String value) {
getClient(key).hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
getClient(key).hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(String key, String field, String value) {
getClient(key).hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
getClient(key).hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hvals(String key) {
getClient(key).hvals(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> hvals(byte[] key) {
getClient(key).hvals(key);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> incr(String key) {
getClient(key).incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incr(byte[] key) {
getClient(key).incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(String key, long integer) {
getClient(key).incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(byte[] key, long integer) {
getClient(key).incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> incrByFloat(String key, double value) {
getClient(key).incrByFloat(key, value);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Double> incrByFloat(byte[] key, double value) {
getClient(key).incrByFloat(key, value);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<String> lindex(String key, int index) {
getClient(key).lindex(key, index);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> lindex(byte[] key, int index) {
getClient(key).lindex(key, index);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> linsert(String key, LIST_POSITION where,
String pivot, String value) {
getClient(key).linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> linsert(byte[] key, LIST_POSITION where,
byte[] pivot, byte[] value) {
getClient(key).linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(String key) {
getClient(key).llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(byte[] key) {
getClient(key).llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lpop(String key) {
getClient(key).lpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> lpop(byte[] key) {
getClient(key).lpop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> lpush(String key, String... string) {
getClient(key).lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpush(byte[] key, byte[]... string) {
getClient(key).lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(String key, String... string) {
getClient(key).lpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(byte[] key, byte[]... bytes) {
getClient(key).lpushx(key, bytes);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> lrange(String key, long start, long end) {
getClient(key).lrange(key, start, end);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
getClient(key).lrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<Long> lrem(String key, long count, String value) {
getClient(key).lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lrem(byte[] key, long count, byte[] value) {
getClient(key).lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lset(String key, long index, String value) {
getClient(key).lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> lset(byte[] key, long index, byte[] value) {
getClient(key).lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(String key, long start, long end) {
getClient(key).ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(byte[] key, long start, long end) {
getClient(key).ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> move(String key, int dbIndex) {
getClient(key).move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> move(byte[] key, int dbIndex) {
getClient(key).move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(String key) {
getClient(key).persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(byte[] key) {
getClient(key).persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rpop(String key) {
getClient(key).rpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> rpop(byte[] key) {
getClient(key).rpop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> rpush(String key, String... string) {
getClient(key).rpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpush(byte[] key, byte[]... string) {
getClient(key).rpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpushx(String key, String... string) {
getClient(key).rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> rpushx(byte[] key, byte[]... string) {
getClient(key).rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(String key, String... member) {
getClient(key).sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(byte[] key, byte[]... member) {
getClient(key).sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(String key) {
getClient(key).scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(byte[] key) {
getClient(key).scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> set(String key, String value) {
getClient(key).set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> set(byte[] key, byte[] value) {
getClient(key).set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> setbit(String key, long offset, boolean value) {
getClient(key).setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
getClient(key).setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> setex(String key, int seconds, String value) {
getClient(key).setex(key, seconds, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> setex(byte[] key, int seconds, byte[] value) {
getClient(key).setex(key, seconds, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> setnx(String key, String value) {
getClient(key).setnx(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> setnx(byte[] key, byte[] value) {
getClient(key).setnx(key, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> setrange(String key, long offset, String value) {
getClient(key).setrange(key, offset, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> setrange(byte[] key, long offset, byte[] value) {
getClient(key).setrange(key, offset, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(String key, String member) {
getClient(key).sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> sismember(byte[] key, byte[] member) {
getClient(key).sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Set<String>> smembers(String key) {
getClient(key).smembers(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Set<byte[]>> smembers(byte[] key) {
getClient(key).smembers(key);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<List<String>> sort(String key) {
getClient(key).sort(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> sort(byte[] key) {
getClient(key).sort(key);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<List<String>> sort(String key,
SortingParams sortingParameters) {
getClient(key).sort(key, sortingParameters);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<byte[]>> sort(byte[] key,
SortingParams sortingParameters) {
getClient(key).sort(key, sortingParameters);
return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
}
public Response<String> spop(String key) {
getClient(key).spop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> spop(byte[] key) {
getClient(key).spop(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<String> srandmember(String key) {
getClient(key).srandmember(key);
return getResponse(BuilderFactory.STRING);
}
public Response<byte[]> srandmember(byte[] key) {
getClient(key).srandmember(key);
return getResponse(BuilderFactory.BYTE_ARRAY);
}
public Response<Long> srem(String key, String member) {
getClient(key).srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> srem(byte[] key, byte[] member) {
getClient(key).srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(String key) {
getClient(key).strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(byte[] key) {
getClient(key).strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(String key, int start, int end) {
getClient(key).substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<String> substr(byte[] key, int start, int end) {
getClient(key).substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> ttl(String key) {
getClient(key).ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(byte[] key) {
getClient(key).ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> type(String key) {
getClient(key).type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> type(byte[] key) {
getClient(key).type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(String key, double score, String member) {
getClient(key).zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zadd(byte[] key, double score, byte[] member) {
getClient(key).zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(String key) {
getClient(key).zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(byte[] key) {
getClient(key).zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(String key, double min, double max) {
getClient(key).zcount(key, min, max);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(byte[] key, double min, double max) {
getClient(key).zcount(key, toByteArray(min), toByteArray(max));
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(String key, double score, String member) {
getClient(key).zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Double> zincrby(byte[] key, double score, byte[] member) {
getClient(key).zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Set<String>> zrange(String key, int start, int end) {
getClient(key).zrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
getClient(key).zrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min,
double max) {
getClient(key).zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max) {
return zrangeByScore(key, toByteArray(min), toByteArray(max));
}
public Response<Set<String>> zrangeByScore(String key, String min,
String max) {
getClient(key).zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max) {
getClient(key).zrangeByScore(key, min, max);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min,
double max, int offset, int count) {
getClient(key).zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
double max, int offset, int count) {
return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
}
public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
byte[] max, int offset, int count) {
getClient(key).zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max) {
getClient(key).zrangeByScoreWithScores(key, min, max);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max) {
return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max) {
getClient(key).zrangeByScoreWithScores(key, min, max);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count) {
getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count) {
getClient(key).zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
byte[] max, int offset, int count) {
getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<String>> zrevrangeByScore(String key, double max,
double min) {
getClient(key).zrevrangeByScore(key, max, min);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
double min) {
getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min));
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<String>> zrevrangeByScore(String key, String max,
String min) {
getClient(key).zrevrangeByScore(key, max, min);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
byte[] min) {
getClient(key).zrevrangeByScore(key, max, min);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<String>> zrevrangeByScore(String key, double max,
double min, int offset, int count) {
getClient(key).zrevrangeByScore(key, max, min, offset, count);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
double min, int offset, int count) {
getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
byte[] min, int offset, int count) {
getClient(key).zrevrangeByScore(key, max, min, offset, count);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
double max, double min) {
getClient(key).zrevrangeByScoreWithScores(key, max, min);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
double max, double min) {
getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
byte[] max, byte[] min) {
getClient(key).zrevrangeByScoreWithScores(key, max, min);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
double max, double min, int offset, int count) {
getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
double max, double min, int offset, int count) {
getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
byte[] max, byte[] min, int offset, int count) {
getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
getClient(key).zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
getClient(key).zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
}
public Response<Long> zrank(String key, String member) {
getClient(key).zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrank(byte[] key, byte[] member) {
getClient(key).zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(String key, String member) {
getClient(key).zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(byte[] key, byte[] member) {
getClient(key).zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(String key, int start, int end) {
getClient(key).zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
getClient(key).zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(String key, double start, double end) {
getClient(key).zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
getClient(key).zremrangeByScore(key, toByteArray(start), toByteArray(end));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
getClient(key).zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrevrange(String key, int start, int end) {
getClient(key).zrevrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
getClient(key).zrevrange(key, start, end);
return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
int end) {
getClient(key).zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
int end) {
getClient(key).zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrevrank(String key, String member) {
getClient(key).zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrevrank(byte[] key, byte[] member) {
getClient(key).zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(String key, String member) {
getClient(key).zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Double> zscore(byte[] key, byte[] member) {
getClient(key).zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> bitcount(String key) {
getClient(key).bitcount(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> bitcount(String key, long start, long end) {
getClient(key).bitcount(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> bitcount(byte[] key) {
getClient(key).bitcount(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> bitcount(byte[] key, long start, long end) {
getClient(key).bitcount(key, start, end);
return getResponse(BuilderFactory.LONG);
}
}

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

@@ -24,6 +24,12 @@ public final class Protocol {
public static final byte MINUS_BYTE = '-';
public static final byte COLON_BYTE = ':';
public static final String SENTINEL_MASTERS = "masters";
public static final String SENTINEL_GET_MASTER_ADDR_BY_NAME = "get-master-addr-by-name";
public static final String SENTINEL_RESET = "reset";
public static final String SENTINEL_SLAVES = "slaves";
public static final String SENTINEL_IS_MASTER_DOWN_BY_ADDR = "is-master-down-by-addr";
private Protocol() {
// this prevent the class from instantiation
}
@@ -131,6 +137,10 @@ public final class Protocol {
return process(is);
}
public static final byte[] toByteArray(final boolean value) {
return toByteArray(value ? 1 : 0);
}
public static final byte[] toByteArray(final int value) {
return SafeEncoder.encode(String.valueOf(value));
}
@@ -144,7 +154,7 @@ public final class Protocol {
}
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, INCRBYFLOAT, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HINCRBYFLOAT, 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;
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, INCRBYFLOAT, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HINCRBYFLOAT, 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;
public final byte[] raw;
@@ -154,7 +164,7 @@ public final class Protocol {
}
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;
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;
public final byte[] raw;
Keyword() {

200
src/main/java/redis/clients/jedis/RedisPipeline.java Normal file
View File

@@ -0,0 +1,200 @@
package redis.clients.jedis;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author guy
*/
public interface RedisPipeline {
Response<Long> append(String key, String value);
Response<List<String>> blpop(String arg);
Response<List<String>> brpop(String arg);
Response<Long> decr(String key);
Response<Long> decrBy(String key, long integer);
Response<Long> del(String key);
Response<String> echo(String string);
Response<Boolean> exists(String key);
Response<Long> expire(String key, int seconds);
Response<Long> expireAt(String key, long unixTime);
Response<String> get(String key);
Response<Boolean> getbit(String key, long offset);
Response<String> getrange(String key, long startOffset,
long endOffset);
Response<String> getSet(String key, String value);
Response<Long> hdel(String key, String field);
Response<Boolean> hexists(String key, String field);
Response<String> hget(String key, String field);
Response<Map<String, String>> hgetAll(String key);
Response<Long> hincrBy(String key, String field, long value);
Response<Set<String>> hkeys(String key);
Response<Long> hlen(String key);
Response<List<String>> hmget(String key, String... fields);
Response<String> hmset(String key, Map<String, String> hash);
Response<Long> hset(String key, String field, String value);
Response<Long> hsetnx(String key, String field, String value);
Response<List<String>> hvals(String key);
Response<Long> incr(String key);
Response<Long> incrBy(String key, long integer);
Response<String> lindex(String key, int index);
Response<Long> linsert(String key, BinaryClient.LIST_POSITION where,
String pivot, String value);
Response<Long> llen(String key);
Response<String> lpop(String key);
Response<Long> lpush(String key, String... string);
Response<Long> lpushx(String key, String... string);
Response<List<String>> lrange(String key, long start, long end);
Response<Long> lrem(String key, long count, String value);
Response<String> lset(String key, long index, String value);
Response<String> ltrim(String key, long start, long end);
Response<Long> move(String key, int dbIndex);
Response<Long> persist(String key);
Response<String> rpop(String key);
Response<Long> rpush(String key, String... string);
Response<Long> rpushx(String key, String... string);
Response<Long> sadd(String key, String... member);
Response<Long> scard(String key);
Response<Boolean> sismember(String key, String member);
Response<String> set(String key, String value);
Response<Boolean> setbit(String key, long offset, boolean value);
Response<String> setex(String key, int seconds, String value);
Response<Long> setnx(String key, String value);
Response<Long> setrange(String key, long offset, String value);
Response<Set<String>> smembers(String key);
Response<List<String>> sort(String key);
Response<List<String>> sort(String key,
SortingParams sortingParameters);
Response<String> spop(String key);
Response<String> srandmember(String key);
Response<Long> srem(String key, String member);
Response<Long> strlen(String key);
Response<String> substr(String key, int start, int end);
Response<Long> ttl(String key);
Response<String> type(String key);
Response<Long> zadd(String key, double score, String member);
Response<Long> zcard(String key);
Response<Long> zcount(String key, double min, double max);
Response<Double> zincrby(String key, double score, String member);
Response<Set<String>> zrange(String key, int start, int end);
Response<Set<String>> zrangeByScore(String key, double min,
double max);
Response<Set<String>> zrangeByScore(String key, String min,
String max);
Response<Set<String>> zrangeByScore(String key, double min,
double max, int offset, int count);
Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max);
Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count);
Response<Set<String>> zrevrangeByScore(String key, double max,
double min);
Response<Set<String>> zrevrangeByScore(String key, String max,
String min);
Response<Set<String>> zrevrangeByScore(String key, double max,
double min, int offset, int count);
Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
double max, double min);
Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
double max, double min, int offset, int count);
Response<Set<Tuple>> zrangeWithScores(String key, int start, int end);
Response<Long> zrank(String key, String member);
Response<Long> zrem(String key, String member);
Response<Long> zremrangeByRank(String key, int start, int end);
Response<Long> zremrangeByScore(String key, double start, double end);
Response<Set<String>> zrevrange(String key, int start, int end);
Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
int end);
Response<Long> zrevrank(String key, String member);
Response<Double> zscore(String key, String member);
Response<Long> bitcount(String key);
Response<Long> bitcount(String key, long start, long end);
}

23
src/main/java/redis/clients/jedis/ScriptingCommands.java Normal file
View File

@@ -0,0 +1,23 @@
package redis.clients.jedis;
import java.util.List;
public interface ScriptingCommands {
Object eval(String script, int keyCount, String... params);
Object eval(String script, List<String> keys, List<String> args);
Object eval(String script);
Object evalsha(String script);
Object evalsha(String sha1, List<String> keys, List<String> args);
Object evalsha(String sha1, int keyCount, String... params);
Boolean scriptExists(String sha1);
List<Boolean> scriptExists(String... sha1);
String scriptLoad(String script);
}

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

@@ -1,13 +1,13 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import java.util.List;
import java.util.Map;
import java.util.Set;
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 ShardedJedis(List<JedisShardInfo> shards) {
super(shards);
@@ -26,13 +26,6 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
super(shards, algo, keyTagPattern);
}
public void disconnect() {
for (Jedis jedis : getAllShards()) {
jedis.quit();
jedis.disconnect();
}
}
public String set(String key, String value) {
Jedis j = getShard(key);
return j.set(key, value);
@@ -43,6 +36,11 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.get(key);
}
public String echo(String string) {
Jedis j = getShard(string);
return j.echo(string);
}
public Boolean exists(String key) {
Jedis j = getShard(key);
return j.exists(key);
@@ -73,6 +71,11 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.setbit(key, offset, value);
}
public Boolean setbit(String key, long offset, String value) {
Jedis j = getShard(key);
return j.setbit(key, offset, value);
}
public Boolean getbit(String key, long offset) {
Jedis j = getShard(key);
return j.getbit(key, offset);
@@ -103,6 +106,16 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.setex(key, seconds, value);
}
public List<String> blpop(String arg) {
Jedis j = getShard(arg);
return j.blpop(arg);
}
public List<String> brpop(String arg) {
Jedis j = getShard(arg);
return j.brpop(arg);
}
public Long decrBy(String key, long integer) {
Jedis j = getShard(key);
return j.decrBy(key, integer);
@@ -218,16 +231,31 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.lpush(key, strings);
}
public Long lpushx(String key, String string) {
public Long lpushx(String key, String... string) {
Jedis j = getShard(key);
return j.lpushx(key, string);
}
public Long rpushx(String key, String string) {
public Long strlen(final String key) {
Jedis j = getShard(key);
return j.strlen(key);
}
public Long move(String key, int dbIndex) {
Jedis j = getShard(key);
return j.move(key, dbIndex);
}
public Long rpushx(String key, String... string) {
Jedis j = getShard(key);
return j.rpushx(key, string);
}
public Long persist(final String key) {
Jedis j = getShard(key);
return j.persist(key);
}
public Long llen(String key) {
Jedis j = getShard(key);
return j.llen(key);
@@ -493,4 +521,16 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
Jedis j = getShard(key);
return j.linsert(key, where, pivot, value);
}
public Long bitcount(final String key) {
Jedis j = getShard(key);
return j.bitcount(key);
}
public Long bitcount(final String key, long start, long end) {
Jedis j = getShard(key);
return j.bitcount(key, start, end);
}
}

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

@@ -1,10 +1,11 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.*;
public class ShardedJedisPipeline extends Queable {
public class ShardedJedisPipeline extends PipelineBase {
private BinaryShardedJedis jedis;
private List<FutureResult> results = new ArrayList<FutureResult>();
private Queue<Client> clients = new LinkedList<Client>();
@@ -25,521 +26,6 @@ public class ShardedJedisPipeline extends Queable {
this.jedis = jedis;
}
public Response<String> set(String key, String value) {
Client c = getClient(key);
c.set(key, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<String> get(String key) {
Client c = getClient(key);
c.get(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> del(String key) {
Client c = getClient(key);
c.del(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> exists(String key) {
Client c = getClient(key);
c.exists(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> type(String key) {
Client c = getClient(key);
c.type(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> expire(String key, int seconds) {
Client c = getClient(key);
c.expire(key, seconds);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(String key, long unixTime) {
Client c = getClient(key);
c.expireAt(key, unixTime);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(String key) {
Client c = getClient(key);
c.ttl(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> getSet(String key, String value) {
Client c = getClient(key);
c.getSet(key, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> setnx(String key, String value) {
Client c = getClient(key);
c.setnx(key, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> setex(String key, int seconds, String value) {
Client c = getClient(key);
c.setex(key, seconds, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decrBy(String key, long integer) {
Client c = getClient(key);
c.decrBy(key, integer);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decr(String key) {
Client c = getClient(key);
c.decr(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(String key, int integer) {
Client c = getClient(key);
c.incrBy(key, integer);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Double> incrByFloat(String key, double value) {
Client c = getClient(key);
c.incrByFloat(key, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> incr(String key) {
Client c = getClient(key);
c.incr(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> append(String key, String value) {
Client c = getClient(key);
c.append(key, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(String key, int start, int end) {
Client c = getClient(key);
c.substr(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hset(String key, String field, String value) {
Client c = getClient(key);
c.hset(key, field, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> hget(String key, String field) {
Client c = getClient(key);
c.hget(key, field);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hsetnx(String key, String field, String value) {
Client c = getClient(key);
c.hsetnx(key, field, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> hmset(String key, Map<String, String> hash) {
Client c = getClient(key);
c.hmset(key, hash);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<List<String>> hmget(String key, String... fields) {
Client c = getClient(key);
c.hmget(key, fields);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> hincrBy(String key, String field, int value) {
Client c = getClient(key);
c.hincrBy(key, field, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Double> hincrByFloat(String key, String field, double value) {
Client c = getClient(key);
c.hincrByFloat(key, field, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Boolean> hexists(String key, String field) {
Client c = getClient(key);
c.hexists(key, field);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> hdel(String key, String field) {
Client c = getClient(key);
c.hdel(key, field);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hlen(String key) {
Client c = getClient(key);
c.hlen(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> hkeys(String key) {
Client c = getClient(key);
c.hkeys(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Set<String>> hvals(String key) {
Client c = getClient(key);
c.hvals(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Map<String, String>> hgetAll(String key) {
Client c = getClient(key);
c.hgetAll(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Long> rpush(String key, String string) {
Client c = getClient(key);
c.rpush(key, string);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpush(String key, String string) {
Client c = getClient(key);
c.lpush(key, string);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(String key) {
Client c = getClient(key);
c.llen(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> lrange(String key, int start, int end) {
Client c = getClient(key);
c.lrange(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> ltrim(String key, int start, int end) {
Client c = getClient(key);
c.ltrim(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<String> lindex(String key, int index) {
Client c = getClient(key);
c.lindex(key, index);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<String> lset(String key, int index, String value) {
Client c = getClient(key);
c.lset(key, index, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lrem(String key, int count, String value) {
Client c = getClient(key);
c.lrem(key, count, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> lpop(String key) {
Client c = getClient(key);
c.lpop(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<String> rpop(String key) {
Client c = getClient(key);
c.rpop(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> sadd(String key, String member) {
Client c = getClient(key);
c.sadd(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> smembers(String key) {
Client c = getClient(key);
c.smembers(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> srem(String key, String member) {
Client c = getClient(key);
c.srem(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<String> spop(String key) {
Client c = getClient(key);
c.spop(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> scard(String key) {
Client c = getClient(key);
c.scard(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(String key, String member) {
Client c = getClient(key);
c.sismember(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> srandmember(String key) {
Client c = getClient(key);
c.srandmember(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(String key, double score, String member) {
Client c = getClient(key);
c.zadd(key, score, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrange(String key, int start, int end) {
Client c = getClient(key);
c.zrange(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Long> zrem(String key, String member) {
Client c = getClient(key);
c.zrem(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(String key, double score, String member) {
Client c = getClient(key);
c.zincrby(key, score, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zrank(String key, String member) {
Client c = getClient(key);
c.zrank(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrevrank(String key, String member) {
Client c = getClient(key);
c.zrevrank(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrevrange(String key, int start, int end) {
Client c = getClient(key);
c.zrevrange(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
Client c = getClient(key);
c.zrangeWithScores(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(String key, int start, int end) {
Client c = getClient(key);
c.zrevrangeWithScores(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zcard(String key) {
Client c = getClient(key);
c.zcard(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(String key, String member) {
Client c = getClient(key);
c.zscore(key, member);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Double> sort(String key) {
Client c = getClient(key);
c.sort(key);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.DOUBLE);
}
public Response<List<String>> sort(String key, SortingParams sortingParameters) {
Client c = getClient(key);
c.sort(key, sortingParameters);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> zcount(String key, double min, double max) {
Client c = getClient(key);
c.zcount(key, min, max);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrangeByScore(String key, double min, double max) {
Client c = getClient(key);
c.zrangeByScore(key, min, max);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min, double max,
int offset, int count) {
Client c = getClient(key);
c.zrangeByScore(key, min, max, offset, count);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
Client c = getClient(key);
c.zrangeByScoreWithScores(key, min, max);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max,
int offset, int count) {
Client c = getClient(key);
c.zrangeByScoreWithScores(key, min, max, offset, count);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zremrangeByRank(String key, int start, int end) {
Client c = getClient(key);
c.zremrangeByRank(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(String key, double start, double end) {
Client c = getClient(key);
c.zremrangeByScore(key, start, end);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> linsert(String key, LIST_POSITION where, String pivot,
String value) {
Client c = getClient(key);
c.linsert(key, where, pivot, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> getbit(String key, long offset) {
Client c = getClient(key);
c.getbit(key, offset);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Boolean> setbit(String key, long offset, boolean value) {
Client c = getClient(key);
c.setbit(key, offset, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> setrange(String key, long offset, String value) {
Client c = getClient(key);
c.setrange(key, offset, value);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public Response<Long> getrange(String key, long startOffset, long endOffset) {
Client c = getClient(key);
c.getrange(key, startOffset, endOffset);
results.add(new FutureResult(c));
return getResponse(BuilderFactory.LONG);
}
public List<Object> getResults() {
List<Object> r = new ArrayList<Object>();
for (FutureResult fr : results) {
@@ -583,9 +69,19 @@ public class ShardedJedisPipeline extends Queable {
public void execute() {
}
private Client getClient(String key) {
@Override
protected Client getClient(String key) {
Client client = jedis.getShard(key).getClient();
clients.add(client);
results.add(new FutureResult(client));
return client;
}
@Override
protected Client getClient(byte[] key) {
Client client = jedis.getShard(key).getClient();
clients.add(client);
results.add(new FutureResult(client));
return client;
}
}

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

@@ -1,579 +1,75 @@
package redis.clients.jedis;
import redis.clients.jedis.exceptions.JedisDataException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
/**
* Transaction is nearly identical to Pipeline, only differences are the multi/discard behaviors
*/
public class Transaction extends MultiKeyPipelineBase {
public class Transaction extends BinaryTransaction {
public Transaction() {
protected boolean inTransaction = true;
protected Transaction(){
// client will be set later in transaction block
}
public Transaction(final Client client) {
super(client);
this.client = client;
}
public Response<Long> append(String key, String value) {
client.append(key, value);
return getResponse(BuilderFactory.LONG);
@Override
protected Client getClient(String key) {
return client;
}
public Response<List<String>> blpop(String... args) {
client.blpop(args);
return getResponse(BuilderFactory.STRING_LIST);
@Override
protected Client getClient(byte[] key) {
return client;
}
public Response<List<String>> brpop(String... args) {
client.brpop(args);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> decr(String key) {
client.decr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> decrBy(String key, long integer) {
client.decrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> del(String... keys) {
client.del(keys);
return getResponse(BuilderFactory.LONG);
}
public Response<String> echo(String string) {
client.echo(string);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> exists(String key) {
client.exists(key);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Long> expire(String key, int seconds) {
client.expire(key, seconds);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> expireAt(String key, long unixTime) {
client.expireAt(key, unixTime);
return getResponse(BuilderFactory.LONG);
}
public Response<String> get(String key) {
client.get(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> getbit(String key, long offset) {
client.getbit(key, offset);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> getrange(String key, long startOffset,
long endOffset) {
client.getrange(key, startOffset, endOffset);
return getResponse(BuilderFactory.STRING);
}
public Response<String> getSet(String key, String value) {
client.getSet(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hdel(String key, String field) {
client.hdel(key, field);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> hexists(String key, String field) {
client.hexists(key, field);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<String> hget(String key, String field) {
client.hget(key, field);
return getResponse(BuilderFactory.STRING);
}
public Response<Map<String, String>> hgetAll(String key) {
client.hgetAll(key);
return getResponse(BuilderFactory.STRING_MAP);
}
public Response<Long> hincrBy(String key, String field, long value) {
client.hincrBy(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> hkeys(String key) {
client.hkeys(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> hlen(String key) {
client.hlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hmget(String key, String... fields) {
client.hmget(key, fields);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> hmset(String key, Map<String, String> hash) {
client.hmset(key, hash);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> hset(String key, String field, String value) {
client.hset(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> hsetnx(String key, String field, String value) {
client.hsetnx(key, field, value);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> hvals(String key) {
client.hvals(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> incr(String key) {
client.incr(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> incrBy(String key, long integer) {
client.incrBy(key, integer);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> keys(String pattern) {
client.keys(pattern);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<String> lindex(String key, int index) {
client.lindex(key, index);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> linsert(String key, LIST_POSITION where,
String pivot, String value) {
client.linsert(key, where, pivot, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> llen(String key) {
client.llen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lpop(String key) {
client.lpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lpush(String key, String string) {
client.lpush(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> lpushx(String key, String string) {
client.lpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> lrange(String key, long start, long end) {
client.lrange(key, start, end);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> lrem(String key, long count, String value) {
client.lrem(key, count, value);
return getResponse(BuilderFactory.LONG);
}
public Response<String> lset(String key, long index, String value) {
client.lset(key, index, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> ltrim(String key, long start, long end) {
client.ltrim(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<List<String>> mget(String... keys) {
client.mget(keys);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<Long> move(String key, int dbIndex) {
client.move(key, dbIndex);
return getResponse(BuilderFactory.LONG);
}
public Response<String> mset(String... keysvalues) {
client.mset(keysvalues);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> msetnx(String... keysvalues) {
client.msetnx(keysvalues);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> persist(String key) {
client.persist(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rename(String oldkey, String newkey) {
client.rename(oldkey, newkey);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> renamenx(String oldkey, String newkey) {
client.renamenx(oldkey, newkey);
return getResponse(BuilderFactory.LONG);
}
public Response<String> rpop(String key) {
client.rpop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> rpoplpush(String srckey, String dstkey) {
client.rpoplpush(srckey, dstkey);
return getResponse(BuilderFactory.STRING);
}
public List<Object> exec() {
client.exec();
client.getAll(1); // Discard all but the last reply
public Response<Long> rpush(String key, String string) {
client.rpush(key, string);
return getResponse(BuilderFactory.LONG);
List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) {
return null;
}
List<Object> formatted = new ArrayList<Object>();
for (Object o : unformatted) {
try {
formatted.add(generateResponse(o).get());
} catch (JedisDataException e) {
formatted.add(e);
}
}
return formatted;
}
public Response<Long> rpushx(String key, String string) {
client.rpushx(key, string);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> sadd(String key, String member) {
client.sadd(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> scard(String key) {
client.scard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> sdiff(String... keys) {
client.sdiff(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sdiffstore(String dstkey, String... keys) {
client.sdiffstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<String> set(String key, String value) {
client.set(key, value);
return getResponse(BuilderFactory.STRING);
}
public Response<Boolean> setbit(String key, long offset, boolean value) {
client.setbit(key, offset, value);
return getResponse(BuilderFactory.BOOLEAN);
}
public List<Response<?>> execGetResponse() {
client.exec();
client.getAll(1); // Discard all but the last reply
public Response<String> setex(String key, int seconds, String value) {
client.setex(key, seconds, value);
return getResponse(BuilderFactory.STRING);
List<Object> unformatted = client.getObjectMultiBulkReply();
if (unformatted == null) {
return null;
}
List<Response<?>> response = new ArrayList<Response<?>>();
for (Object o : unformatted) {
response.add(generateResponse(o));
}
return response;
}
public Response<Long> setnx(String key, String value) {
client.setnx(key, value);
return getResponse(BuilderFactory.LONG);
public String discard() {
client.discard();
client.getAll(1); // Discard all but the last reply
inTransaction = false;
clean();
return client.getStatusCodeReply();
}
public Response<Long> setrange(String key, long offset, String value) {
client.setrange(key, offset, value);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> sinter(String... keys) {
client.sinter(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sinterstore(String dstkey, String... keys) {
client.sinterstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Boolean> sismember(String key, String member) {
client.sismember(key, member);
return getResponse(BuilderFactory.BOOLEAN);
}
public Response<Set<String>> smembers(String key) {
client.smembers(key);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> smove(String srckey, String dstkey, String member) {
client.smove(srckey, dstkey, member);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(String key) {
client.sort(key);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key,
SortingParams sortingParameters) {
client.sort(key, sortingParameters);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key,
SortingParams sortingParameters, String dstkey) {
client.sort(key, sortingParameters, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<List<String>> sort(String key, String dstkey) {
client.sort(key, dstkey);
return getResponse(BuilderFactory.STRING_LIST);
}
public Response<String> spop(String key) {
client.spop(key);
return getResponse(BuilderFactory.STRING);
}
public Response<String> srandmember(String key) {
client.srandmember(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> srem(String key, String member) {
client.srem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> strlen(String key) {
client.strlen(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> substr(String key, int start, int end) {
client.substr(key, start, end);
return getResponse(BuilderFactory.STRING);
}
public Response<Set<String>> sunion(String... keys) {
client.sunion(keys);
return getResponse(BuilderFactory.STRING_SET);
}
public Response<Long> sunionstore(String dstkey, String... keys) {
client.sunionstore(dstkey, keys);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> ttl(String key) {
client.ttl(key);
return getResponse(BuilderFactory.LONG);
}
public Response<String> type(String key) {
client.type(key);
return getResponse(BuilderFactory.STRING);
}
public Response<Long> zadd(String key, double score, String member) {
client.zadd(key, score, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcard(String key) {
client.zcard(key);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zcount(String key, double min, double max) {
client.zcount(key, min, max);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zincrby(String key, double score, String member) {
client.zincrby(key, score, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zinterstore(String dstkey, String... sets) {
client.zinterstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zinterstore(String dstkey, ZParams params,
String... sets) {
client.zinterstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrange(String key, int start, int end) {
client.zrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min,
double max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, String min,
String max) {
client.zrangeByScore(key, min, max);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<String>> zrangeByScore(String key, double min,
double max, int offset, int count) {
client.zrangeByScore(key, min, max, offset, count);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max) {
client.zrangeByScoreWithScores(key, min, max);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count) {
client.zrangeByScoreWithScores(key, min, max, offset, count);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
client.zrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrank(String key, String member) {
client.zrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zrem(String key, String member) {
client.zrem(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByRank(String key, int start, int end) {
client.zremrangeByRank(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zremrangeByScore(String key, double start, double end) {
client.zremrangeByScore(key, start, end);
return getResponse(BuilderFactory.LONG);
}
public Response<Set<String>> zrevrange(String key, int start, int end) {
client.zrevrange(key, start, end);
return getResponse(BuilderFactory.STRING_ZSET);
}
public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
int end) {
client.zrevrangeWithScores(key, start, end);
return getResponse(BuilderFactory.TUPLE_ZSET);
}
public Response<Long> zrevrank(String key, String member) {
client.zrevrank(key, member);
return getResponse(BuilderFactory.LONG);
}
public Response<Double> zscore(String key, String member) {
client.zscore(key, member);
return getResponse(BuilderFactory.DOUBLE);
}
public Response<Long> zunionstore(String dstkey, String... sets) {
client.zunionstore(dstkey, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> zunionstore(String dstkey, ZParams params,
String... sets) {
client.zunionstore(dstkey, params, sets);
return getResponse(BuilderFactory.LONG);
}
public Response<String> bgrewriteaof() {
client.bgrewriteaof();
return getResponse(BuilderFactory.STRING);
}
public Response<String> bgsave() {
client.bgsave();
return getResponse(BuilderFactory.STRING);
}
public Response<String> configGet(String pattern) {
client.configGet(pattern);
return getResponse(BuilderFactory.STRING);
}
public Response<String> configSet(String parameter, String value) {
client.configSet(parameter, value);
return getResponse(BuilderFactory.STRING);
}
public Response<String> brpoplpush(String source, String destination,
int timeout) {
client.brpoplpush(source, destination, timeout);
return getResponse(BuilderFactory.STRING);
}
public Response<String> configResetStat() {
client.configResetStat();
return getResponse(BuilderFactory.STRING);
}
public Response<String> save() {
client.save();
return getResponse(BuilderFactory.STRING);
}
public Response<Long> lastsave() {
client.lastsave();
return getResponse(BuilderFactory.LONG);
}
public Response<Long> publish(String channel, String message) {
client.publish(channel, message);
return getResponse(BuilderFactory.LONG);
}
public Response<Long> publish(byte[] channel, byte[] message) {
client.publish(channel, message);
return getResponse(BuilderFactory.LONG);
}
}

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 void setClient(Client client) {
this.client = client;
this.client = client;
}
}

68
src/test/java/redis/clients/jedis/tests/JedisSentinelTest.java Normal file
View File

@@ -0,0 +1,68 @@
package redis.clients.jedis.tests;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import java.util.List;
import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
public class JedisSentinelTest {
private static final String MASTER_NAME = "mymaster";
@Before
public void setup() throws InterruptedException {
Jedis j = new Jedis("localhost", 6380);
j.auth("foobared");
j.configSet("masterauth", "foobared");
j.slaveof("localhost", 6379);
// TODO: The sleep is to give time to the slave to synchronize with the
// master and also let know the sentinels about this new topology. We
// should find a better way to do this.
Thread.sleep(5000);
}
@After
public void clear() {
Jedis j = new Jedis("localhost", 6380);
j.auth("foobared");
j.slaveofNoOne();
}
@Test
public void sentinel() {
Jedis j = new Jedis("localhost", 26379);
List<Map<String, String>> masters = j.sentinelMasters();
final String masterName = masters.get(0).get("name");
assertEquals(MASTER_NAME, masterName);
List<String> masterHostAndPort = j
.sentinelGetMasterAddrByName(masterName);
assertEquals("127.0.0.1", masterHostAndPort.get(0));
assertEquals("6379", masterHostAndPort.get(1));
List<Map<String, String>> slaves = j.sentinelSlaves(masterName);
assertEquals("6379", slaves.get(0).get("master-port"));
List<? extends Object> isMasterDownByAddr = j
.sentinelIsMasterDownByAddr("127.0.0.1", 6379);
assertEquals(Long.valueOf(0), (Long) isMasterDownByAddr.get(0));
assertFalse("?".equals(isMasterDownByAddr.get(1)));
isMasterDownByAddr = j.sentinelIsMasterDownByAddr("127.0.0.1", 1);
assertEquals(Long.valueOf(0), (Long) isMasterDownByAddr.get(0));
assertTrue("?".equals(isMasterDownByAddr.get(1)));
// DO NOT RE-RUN TEST TOO FAST, RESET TAKES SOME TIME TO... RESET
assertEquals(Long.valueOf(1), j.sentinelReset(masterName));
assertEquals(Long.valueOf(0), j.sentinelReset("woof" + masterName));
}
}

59
src/test/java/redis/clients/jedis/tests/PipeliningTest.java Normal file → Executable file
View File

@@ -8,10 +8,7 @@ import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.tests.HostAndPortUtil.HostAndPort;
import java.io.UnsupportedEncodingException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.*;
public class PipeliningTest extends Assert {
private static HostAndPort hnp = HostAndPortUtil.getRedisServers().get(0);
@@ -100,7 +97,59 @@ public class PipeliningTest extends Assert {
assertNotNull(score.get());
}
@Test
public void pipelineBinarySafeHashCommands() {
jedis.hset("key".getBytes(), "f1".getBytes(), "v111".getBytes());
jedis.hset("key".getBytes(), "f22".getBytes(), "v2222".getBytes());
Pipeline p = jedis.pipelined();
Response<Map<byte[],byte[]>> fmap = p.hgetAll("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[]>> fvals = p.hvals("key".getBytes());
p.sync();
assertNotNull(fmap.get());
// we have to do these strange contortions because byte[] is not a very good key
// for a java Map. It only works with equality (you need the exact key object to retrieve
// the value) I recommend we switch to using ByteBuffer or something similar:
// http://stackoverflow.com/questions/1058149/using-a-byte-array-as-hashmap-key-java
Map<byte[],byte[]> map = fmap.get();
Set<byte[]> mapKeys = map.keySet();
Iterator<byte[]> iterMap = mapKeys.iterator();
byte[] firstMapKey = iterMap.next();
byte[] secondMapKey = iterMap.next();
assertFalse(iterMap.hasNext());
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());
Iterator<byte[]> iter = fkeys.get().iterator();
byte[] firstKey = iter.next();
byte[] secondKey = iter.next();
assertFalse(iter.hasNext());
verifyHasBothValues(firstKey, secondKey, "f1".getBytes(), "f22".getBytes());
assertNotNull(fordered.get());
assertArrayEquals("v2222".getBytes(), fordered.get().get(0));
assertArrayEquals("v111".getBytes(), fordered.get().get(1));
assertNotNull(fvals.get());
assertEquals(2, fvals.get().size());
byte[] firstValue = fvals.get().get(0);
byte[] secondValue = fvals.get().get(1);
verifyHasBothValues(firstValue, secondValue, "v111".getBytes(), "v2222".getBytes());
}
private void verifyHasBothValues(byte[] firstKey, byte[] secondKey, byte[] value1, byte[] value2) {
assertFalse(Arrays.equals(firstKey, secondKey));
assertTrue(Arrays.equals(firstKey, value1) || Arrays.equals(firstKey, value2));
assertTrue(Arrays.equals(secondKey, value1) || Arrays.equals(secondKey, value2));
}
@Test
public void pipelineSelect() {
Pipeline p = jedis.pipelined();

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

@@ -300,7 +300,7 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
@Test
public void ttl() {
long ttl = jedis.ttl("foo");
assertEquals(-1, ttl);
assertEquals(-2, ttl);
jedis.set("foo", "bar");
ttl = jedis.ttl("foo");
@@ -312,7 +312,7 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
// Binary
long bttl = jedis.ttl(bfoo);
assertEquals(-1, bttl);
assertEquals(-2, bttl);
jedis.set(bfoo, bbar);
bttl = jedis.ttl(bfoo);

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

@@ -2,6 +2,8 @@ package redis.clients.jedis.tests.commands;
import org.junit.Test;
import redis.clients.jedis.BitOP;
public class BitCommandsTest extends JedisCommandTestBase {
@Test
public void setAndgetbit() {
@@ -29,4 +31,63 @@ public class BitCommandsTest extends JedisCommandTestBase {
assertEquals("Hello", jedis.getrange("key1", 0, 4));
assertEquals("Jedis", jedis.getrange("key1", 6, 11));
}
}
@Test
public void bitCount() {
jedis.del("foo");
jedis.setbit("foo", 16, true);
jedis.setbit("foo", 24, true);
jedis.setbit("foo", 40, true);
jedis.setbit("foo", 56, true);
long c4 = jedis.bitcount("foo");
assertEquals(4, c4);
long c3 = jedis.bitcount("foo", 2L, 5L);
assertEquals(3, c3);
jedis.del("foo");
}
@Test
public void bitOp()
{
jedis.set("key1", "\u0060");
jedis.set("key2", "\u0044");
jedis.bitop(BitOP.AND, "resultAnd", "key1", "key2");
String resultAnd = jedis.get("resultAnd");
assertEquals("\u0040", resultAnd);
jedis.bitop(BitOP.OR, "resultOr", "key1", "key2");
String resultOr = jedis.get("resultOr");
assertEquals("\u0064", resultOr);
jedis.bitop(BitOP.XOR, "resultXor", "key1", "key2");
String resultXor = jedis.get("resultXor");
assertEquals("\u0024", resultXor);
jedis.del("resultAnd");
jedis.del("resultOr");
jedis.del("resultXor");
jedis.del("key1");
jedis.del("key2");
}
@Test
public void bitOpNot()
{
jedis.del("key");
jedis.setbit("key", 0, true);
jedis.setbit("key", 4, true);
jedis.bitop(BitOP.NOT, "resultNot", "key");
String resultNot = jedis.get("resultNot");
assertEquals("\u0077", resultNot);
jedis.del("key");
jedis.del("resultNot");
}
}

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

@@ -58,6 +58,8 @@ public class ControlCommandsTest extends JedisCommandTestBase {
public void info() {
String info = jedis.info();
assertNotNull(info);
info = jedis.info("server");
assertNotNull(info);
}
@Test

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

@@ -6,133 +6,147 @@ import java.util.List;
import org.junit.Test;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;
import redis.clients.util.SafeEncoder;
public class ScriptingCommandsTest extends JedisCommandTestBase {
@SuppressWarnings("unchecked")
@Test
@Test
public void evalMultiBulk() {
String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
List<String> keys = new ArrayList<String>();
keys.add("key1");
keys.add("key2");
List<String> args = new ArrayList<String>();
args.add("first");
args.add("second");
List<String> response = (List<String>)jedis.eval(script, keys, args );
assertEquals(4, response.size());
assertEquals("key1", response.get(0));
assertEquals("key2", response.get(1));
assertEquals("first", response.get(2));
assertEquals("second", response.get(3));
String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
List<String> keys = new ArrayList<String>();
keys.add("key1");
keys.add("key2");
List<String> args = new ArrayList<String>();
args.add("first");
args.add("second");
List<String> response = (List<String>) jedis.eval(script, keys, args);
assertEquals(4, response.size());
assertEquals("key1", response.get(0));
assertEquals("key2", response.get(1));
assertEquals("first", response.get(2));
assertEquals("second", response.get(3));
}
@Test
@Test
public void evalBulk() {
String script = "return KEYS[1]";
List<String> keys = new ArrayList<String>();
keys.add("key1");
List<String> args = new ArrayList<String>();
args.add("first");
String response = (String)jedis.eval(script, keys, args);
assertEquals("key1", response);
String script = "return KEYS[1]";
List<String> keys = new ArrayList<String>();
keys.add("key1");
List<String> args = new ArrayList<String>();
args.add("first");
String response = (String) jedis.eval(script, keys, args);
assertEquals("key1", response);
}
@Test
@Test
public void evalInt() {
String script = "return 2";
List<String> keys = new ArrayList<String>();
keys.add("key1");
Long response = (Long)jedis.eval(script, keys, new ArrayList<String>());
assertEquals(new Long(2), response);
String script = "return 2";
List<String> keys = new ArrayList<String>();
keys.add("key1");
Long response = (Long) jedis
.eval(script, keys, new ArrayList<String>());
assertEquals(new Long(2), response);
}
@Test
@Test
public void evalNoArgs() {
String script = "return KEYS[1]";
List<String> keys = new ArrayList<String>();
keys.add("key1");
String response = (String)jedis.eval(script, keys, new ArrayList<String>());
assertEquals("key1", response);
String script = "return KEYS[1]";
List<String> keys = new ArrayList<String>();
keys.add("key1");
String response = (String) jedis.eval(script, keys,
new ArrayList<String>());
assertEquals("key1", response);
}
@SuppressWarnings("unchecked")
@Test
@Test
public void evalsha() {
jedis.set("foo", "bar");
jedis.eval("return redis.call('get','foo')");
String result = (String)jedis.evalsha("6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
assertEquals("bar", result);
jedis.set("foo", "bar");
jedis.eval("return redis.call('get','foo')");
String result = (String) jedis
.evalsha("6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
assertEquals("bar", result);
}
@SuppressWarnings("unchecked")
@Test(expected=JedisDataException.class)
@Test(expected = JedisDataException.class)
public void evalshaShaNotFound() {
jedis.evalsha("ffffffffffffffffffffffffffffffffffffffff");
jedis.evalsha("ffffffffffffffffffffffffffffffffffffffff");
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptFlush() {
jedis.set("foo", "bar");
jedis.eval("return redis.call('get','foo')");
jedis.scriptFlush();
assertFalse(jedis.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
jedis.set("foo", "bar");
jedis.eval("return redis.call('get','foo')");
jedis.scriptFlush();
assertFalse(jedis
.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptExists() {
jedis.scriptLoad("return redis.call('get','foo')");
List<Boolean> exists = jedis.scriptExists("ffffffffffffffffffffffffffffffffffffffff","6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
assertFalse(exists.get(0));
assertTrue(exists.get(1));
jedis.scriptLoad("return redis.call('get','foo')");
List<Boolean> exists = jedis.scriptExists(
"ffffffffffffffffffffffffffffffffffffffff",
"6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
assertFalse(exists.get(0));
assertTrue(exists.get(1));
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptExistsBinary() {
jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
List<Long> exists = jedis.scriptExists(SafeEncoder.encode("ffffffffffffffffffffffffffffffffffffffff"),SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
assertEquals(new Long(0), exists.get(0));
assertEquals(new Long(1), exists.get(1));
jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
List<Long> exists = jedis.scriptExists(
SafeEncoder.encode("ffffffffffffffffffffffffffffffffffffffff"),
SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
assertEquals(new Long(0), exists.get(0));
assertEquals(new Long(1), exists.get(1));
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptLoad() {
jedis.scriptLoad("return redis.call('get','foo')");
assertTrue(jedis.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
jedis.scriptLoad("return redis.call('get','foo')");
assertTrue(jedis
.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptLoadBinary() {
jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
List<Long> exists = jedis.scriptExists(SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
assertEquals(new Long(1), exists.get(0));
jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
List<Long> exists = jedis.scriptExists(SafeEncoder
.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
assertEquals(new Long(1), exists.get(0));
}
@SuppressWarnings("unchecked")
@Test
@Test
public void scriptKill() {
try {
jedis.scriptKill();
}
catch(JedisDataException e) {
assertTrue(e.getMessage().contains("No scripts in execution right now."));
}
try {
jedis.scriptKill();
} catch (JedisDataException e) {
assertTrue(e.getMessage().contains(
"No scripts in execution right now."));
}
}
@Test
public void scriptEvalReturnNullValues() {
String script = "return {redis.call('hget',KEYS[1],ARGV[1]),redis.call('hget',KEYS[2],ARGV[2])}";
jedis.eval(script, 2, "key1", "key2", "1", "1");
}
@Test
public void scriptEvalShaReturnNullValues() {
String script = "return {redis.call('hget',KEYS[1],ARGV[1]),redis.call('hget',KEYS[2],ARGV[2])}";
String sha = jedis.scriptLoad(script);
jedis.evalsha(sha, 2, "key1", "key2", "1", "1");
}
}

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

@@ -171,7 +171,7 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
t.set(bmykey, bval);
resp = t.exec();
assertEquals(1, resp.size());
assertArrayEquals("OK".getBytes(), (byte[]) resp.get(0));
assertEquals("OK", resp.get(0));
}
@Test(expected = JedisDataException.class)