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

Added sharding+pipelining support

Browse Source
This commit is contained in:
Jonathan Leibiusky
2010-11-02 01:04:02 -03:00
parent 7d3fb44639
commit d70c42edb9
5 changed files with 771 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,15 +1,15 @@
package redis.clients.jedis; package redis.clients.jedis;
import redis.clients.util.RedisInputStream; import java.io.IOException;
import redis.clients.util.RedisOutputStream;
import java.io.*;
import java.net.Socket; import java.net.Socket;
import java.net.SocketException; import java.net.SocketException;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import redis.clients.util.RedisInputStream;
import redis.clients.util.RedisOutputStream;
public class Connection { public class Connection {
private String host; private String host;
private int port = Protocol.DEFAULT_PORT; private int port = Protocol.DEFAULT_PORT;
@@ -21,134 +21,139 @@ public class Connection {
private int timeout = 2000; private int timeout = 2000;
public int getTimeout() { public int getTimeout() {
return timeout; return timeout;
} }
public void setTimeout(int timeout) { public void setTimeout(int timeout) {
this.timeout = timeout; this.timeout = timeout;
} }
public void setTimeoutInfinite() { public void setTimeoutInfinite() {
try { try {
socket.setSoTimeout(0); socket.setSoTimeout(0);
} catch (SocketException ex) { } catch (SocketException ex) {
throw new JedisException(ex); throw new JedisException(ex);
} }
} }
public void rollbackTimeout() { public void rollbackTimeout() {
try { try {
socket.setSoTimeout(timeout); socket.setSoTimeout(timeout);
} catch (SocketException ex) { } catch (SocketException ex) {
throw new JedisException(ex); throw new JedisException(ex);
} }
} }
public Connection(String host) { public Connection(String host) {
super(); super();
this.host = host; this.host = host;
} }
protected Connection sendCommand(String name, String... args) { protected Connection sendCommand(String name, String... args) {
try { try {
connect(); connect();
} catch (UnknownHostException e) { } catch (UnknownHostException e) {
throw new JedisException("Could not connect to redis-server", e); throw new JedisException("Could not connect to redis-server", e);
} catch (IOException e) { } catch (IOException e) {
throw new JedisException("Could not connect to redis-server", e); throw new JedisException("Could not connect to redis-server", e);
} }
protocol.sendCommand(outputStream, name, args); protocol.sendCommand(outputStream, name, args);
pipelinedCommands++; pipelinedCommands++;
return this; return this;
} }
public Connection(String host, int port) { public Connection(String host, int port) {
super(); super();
this.host = host; this.host = host;
this.port = port; this.port = port;
} }
public String getHost() { public String getHost() {
return host; return host;
} }
public void setHost(String host) { public void setHost(String host) {
this.host = host; this.host = host;
} }
public int getPort() { public int getPort() {
return port; return port;
} }
public void setPort(int port) { public void setPort(int port) {
this.port = port; this.port = port;
} }
public Connection() { public Connection() {
} }
public void connect() throws UnknownHostException, IOException { public void connect() throws UnknownHostException, IOException {
if (!isConnected()) { if (!isConnected()) {
socket = new Socket(host, port); socket = new Socket(host, port);
socket.setSoTimeout(timeout); socket.setSoTimeout(timeout);
outputStream = new RedisOutputStream(socket.getOutputStream()); outputStream = new RedisOutputStream(socket.getOutputStream());
inputStream = new RedisInputStream(socket.getInputStream()); inputStream = new RedisInputStream(socket.getInputStream());
} }
} }
public void disconnect() { public void disconnect() {
if (isConnected()) { if (isConnected()) {
try { try {
inputStream.close(); inputStream.close();
outputStream.close(); outputStream.close();
if (!socket.isClosed()) { if (!socket.isClosed()) {
socket.close(); socket.close();
} }
} catch (IOException ex) { } catch (IOException ex) {
throw new JedisException(ex); throw new JedisException(ex);
} }
} }
} }
public boolean isConnected() { public boolean isConnected() {
return socket != null && socket.isBound() && !socket.isClosed() return socket != null && socket.isBound() && !socket.isClosed()
&& socket.isConnected() && !socket.isInputShutdown() && socket.isConnected() && !socket.isInputShutdown()
&& !socket.isOutputShutdown(); && !socket.isOutputShutdown();
} }
protected String getStatusCodeReply() { protected String getStatusCodeReply() {
pipelinedCommands--; pipelinedCommands--;
return (String) protocol.read(inputStream); return (String) protocol.read(inputStream);
} }
public String getBulkReply() { public String getBulkReply() {
pipelinedCommands--; pipelinedCommands--;
return (String) protocol.read(inputStream); return (String) protocol.read(inputStream);
} }
public int getIntegerReply() { public int getIntegerReply() {
pipelinedCommands--; pipelinedCommands--;
return ((Integer) protocol.read(inputStream)).intValue(); return ((Integer) protocol.read(inputStream)).intValue();
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<String> getMultiBulkReply() { public List<String> getMultiBulkReply() {
pipelinedCommands--; pipelinedCommands--;
return (List<String>) protocol.read(inputStream); return (List<String>) protocol.read(inputStream);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public List<Object> getObjectMultiBulkReply() { public List<Object> getObjectMultiBulkReply() {
pipelinedCommands--; pipelinedCommands--;
return (List<Object>) protocol.read(inputStream); return (List<Object>) protocol.read(inputStream);
} }
public List<Object> getAll() { public List<Object> getAll() {
List<Object> all = new ArrayList<Object>(); List<Object> all = new ArrayList<Object>();
while (pipelinedCommands > 0) { while (pipelinedCommands > 0) {
all.add(protocol.read(inputStream)); all.add(protocol.read(inputStream));
pipelinedCommands--; pipelinedCommands--;
} }
return all; return all;
} }
}
public Object getOne() {
pipelinedCommands--;
return protocol.read(inputStream);
}
}

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

@@ -2849,4 +2849,8 @@ public class Jedis implements JedisCommands {
client.debug(params); client.debug(params);
return client.getStatusCodeReply(); return client.getStatusCodeReply();
} }
public Client getClient() {
return client;
}
} }

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

@@ -10,365 +10,371 @@ import redis.clients.jedis.Client.LIST_POSITION;
import redis.clients.util.Hashing; import redis.clients.util.Hashing;
import redis.clients.util.Sharded; import redis.clients.util.Sharded;
public class ShardedJedis extends Sharded<Jedis, JedisShardInfo> implements JedisCommands { public class ShardedJedis extends Sharded<Jedis, JedisShardInfo> implements
JedisCommands {
public ShardedJedis(List<JedisShardInfo> shards) { public ShardedJedis(List<JedisShardInfo> shards) {
super(shards); super(shards);
} }
public ShardedJedis(List<JedisShardInfo> shards, Hashing algo) { public ShardedJedis(List<JedisShardInfo> shards, Hashing algo) {
super(shards, algo); super(shards, algo);
} }
public ShardedJedis(List<JedisShardInfo> shards, Pattern keyTagPattern) { public ShardedJedis(List<JedisShardInfo> shards, Pattern keyTagPattern) {
super(shards, keyTagPattern); super(shards, keyTagPattern);
} }
public ShardedJedis(List<JedisShardInfo> shards, Hashing algo, public ShardedJedis(List<JedisShardInfo> shards, Hashing algo,
Pattern keyTagPattern) { Pattern keyTagPattern) {
super(shards, algo, keyTagPattern); super(shards, algo, keyTagPattern);
} }
public void disconnect() throws IOException { public void disconnect() throws IOException {
for (JedisShardInfo jedis : getAllShards()) { for (JedisShardInfo jedis : getAllShards()) {
jedis.getResource().disconnect(); jedis.getResource().disconnect();
} }
} }
protected Jedis create(JedisShardInfo shard) { protected Jedis create(JedisShardInfo shard) {
return new Jedis(shard); return new Jedis(shard);
} }
public String set(String key, String value) { public String set(String key, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.set(key, value); return j.set(key, value);
} }
public String get(String key) { public String get(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.get(key); return j.get(key);
} }
public Integer exists(String key) { public Integer exists(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.exists(key); return j.exists(key);
} }
public String type(String key) { public String type(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.type(key); return j.type(key);
} }
public Integer expire(String key, int seconds) { public Integer expire(String key, int seconds) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.expire(key, seconds); return j.expire(key, seconds);
} }
public Integer expireAt(String key, long unixTime) { public Integer expireAt(String key, long unixTime) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.expireAt(key, unixTime); return j.expireAt(key, unixTime);
} }
public Integer ttl(String key) { public Integer ttl(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.ttl(key); return j.ttl(key);
} }
public String getSet(String key, String value) { public String getSet(String key, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.getSet(key, value); return j.getSet(key, value);
} }
public Integer setnx(String key, String value) { public Integer setnx(String key, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.setnx(key, value); return j.setnx(key, value);
} }
public String setex(String key, int seconds, String value) { public String setex(String key, int seconds, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.setex(key, seconds, value); return j.setex(key, seconds, value);
} }
public Integer decrBy(String key, int integer) { public Integer decrBy(String key, int integer) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.decrBy(key, integer); return j.decrBy(key, integer);
} }
public Integer decr(String key) { public Integer decr(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.decr(key); return j.decr(key);
} }
public Integer incrBy(String key, int integer) { public Integer incrBy(String key, int integer) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.incrBy(key, integer); return j.incrBy(key, integer);
} }
public Integer incr(String key) { public Integer incr(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.incr(key); return j.incr(key);
} }
public Integer append(String key, String value) { public Integer append(String key, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.append(key, value); return j.append(key, value);
} }
public String substr(String key, int start, int end) { public String substr(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.substr(key, start, end); return j.substr(key, start, end);
} }
public Integer hset(String key, String field, String value) { public Integer hset(String key, String field, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hset(key, field, value); return j.hset(key, field, value);
} }
public String hget(String key, String field) { public String hget(String key, String field) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hget(key, field); return j.hget(key, field);
} }
public Integer hsetnx(String key, String field, String value) { public Integer hsetnx(String key, String field, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hsetnx(key, field, value); return j.hsetnx(key, field, value);
} }
public String hmset(String key, Map<String, String> hash) { public String hmset(String key, Map<String, String> hash) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hmset(key, hash); return j.hmset(key, hash);
} }
public List<String> hmget(String key, String... fields) { public List<String> hmget(String key, String... fields) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hmget(key, fields); return j.hmget(key, fields);
} }
public Integer hincrBy(String key, String field, int value) { public Integer hincrBy(String key, String field, int value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hincrBy(key, field, value); return j.hincrBy(key, field, value);
} }
public Integer hexists(String key, String field) { public Integer hexists(String key, String field) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hexists(key, field); return j.hexists(key, field);
} }
public Integer hdel(String key, String field) { public Integer hdel(String key, String field) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hdel(key, field); return j.hdel(key, field);
} }
public Integer hlen(String key) { public Integer hlen(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hlen(key); return j.hlen(key);
} }
public List<String> hkeys(String key) { public List<String> hkeys(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hkeys(key); return j.hkeys(key);
} }
public List<String> hvals(String key) { public List<String> hvals(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hvals(key); return j.hvals(key);
} }
public Map<String, String> hgetAll(String key) { public Map<String, String> hgetAll(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.hgetAll(key); return j.hgetAll(key);
} }
public Integer rpush(String key, String string) { public Integer rpush(String key, String string) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.rpush(key, string); return j.rpush(key, string);
} }
public Integer lpush(String key, String string) { public Integer lpush(String key, String string) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lpush(key, string); return j.lpush(key, string);
} }
public Integer llen(String key) { public Integer llen(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.llen(key); return j.llen(key);
} }
public List<String> lrange(String key, int start, int end) { public List<String> lrange(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lrange(key, start, end); return j.lrange(key, start, end);
} }
public String ltrim(String key, int start, int end) { public String ltrim(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.ltrim(key, start, end); return j.ltrim(key, start, end);
} }
public String lindex(String key, int index) { public String lindex(String key, int index) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lindex(key, index); return j.lindex(key, index);
} }
public String lset(String key, int index, String value) { public String lset(String key, int index, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lset(key, index, value); return j.lset(key, index, value);
} }
public Integer lrem(String key, int count, String value) { public Integer lrem(String key, int count, String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lrem(key, count, value); return j.lrem(key, count, value);
} }
public String lpop(String key) { public String lpop(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.lpop(key); return j.lpop(key);
} }
public String rpop(String key) { public String rpop(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.rpop(key); return j.rpop(key);
} }
public Integer sadd(String key, String member) { public Integer sadd(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.sadd(key, member); return j.sadd(key, member);
} }
public Set<String> smembers(String key) { public Set<String> smembers(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.smembers(key); return j.smembers(key);
} }
public Integer srem(String key, String member) { public Integer srem(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.srem(key, member); return j.srem(key, member);
} }
public String spop(String key) { public String spop(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.spop(key); return j.spop(key);
} }
public Integer scard(String key) { public Integer scard(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.scard(key); return j.scard(key);
} }
public Integer sismember(String key, String member) { public Integer sismember(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.sismember(key, member); return j.sismember(key, member);
} }
public String srandmember(String key) { public String srandmember(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.srandmember(key); return j.srandmember(key);
} }
public Integer zadd(String key, double score, String member) { public Integer zadd(String key, double score, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zadd(key, score, member); return j.zadd(key, score, member);
} }
public Set<String> zrange(String key, int start, int end) { public Set<String> zrange(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrange(key, start, end); return j.zrange(key, start, end);
} }
public Integer zrem(String key, String member) { public Integer zrem(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrem(key, member); return j.zrem(key, member);
} }
public Double zincrby(String key, double score, String member) { public Double zincrby(String key, double score, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zincrby(key, score, member); return j.zincrby(key, score, member);
} }
public Integer zrank(String key, String member) { public Integer zrank(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrank(key, member); return j.zrank(key, member);
} }
public Integer zrevrank(String key, String member) { public Integer zrevrank(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrevrank(key, member); return j.zrevrank(key, member);
} }
public Set<String> zrevrange(String key, int start, int end) { public Set<String> zrevrange(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrevrange(key, start, end); return j.zrevrange(key, start, end);
} }
public Set<Tuple> zrangeWithScores(String key, int start, int end) { public Set<Tuple> zrangeWithScores(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end); return j.zrangeWithScores(key, start, end);
} }
public Set<Tuple> zrevrangeWithScores(String key, int start, int end) { public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end); return j.zrevrangeWithScores(key, start, end);
} }
public Integer zcard(String key) { public Integer zcard(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zcard(key); return j.zcard(key);
} }
public Double zscore(String key, String member) { public Double zscore(String key, String member) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zscore(key, member); return j.zscore(key, member);
} }
public List<String> sort(String key) { public List<String> sort(String key) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.sort(key); return j.sort(key);
} }
public List<String> sort(String key, SortingParams sortingParameters) { public List<String> sort(String key, SortingParams sortingParameters) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.sort(key, sortingParameters); return j.sort(key, sortingParameters);
} }
public Integer zcount(String key, double min, double max) { public Integer zcount(String key, double min, double max) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zcount(key, min, max); return j.zcount(key, min, max);
} }
public Set<String> zrangeByScore(String key, double min, double max) { public Set<String> zrangeByScore(String key, double min, double max) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrangeByScore(key, min, max); return j.zrangeByScore(key, min, max);
} }
public Set<String> zrangeByScore(String key, double min, double max, public Set<String> zrangeByScore(String key, double min, double max,
int offset, int count) { int offset, int count) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count); return j.zrangeByScore(key, min, max, offset, count);
} }
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) { public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max); return j.zrangeByScoreWithScores(key, min, max);
} }
public Set<Tuple> zrangeByScoreWithScores(String key, double min, public Set<Tuple> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count) { double max, int offset, int count) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count); return j.zrangeByScoreWithScores(key, min, max, offset, count);
} }
public Integer zremrangeByRank(String key, int start, int end) { public Integer zremrangeByRank(String key, int start, int end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end); return j.zremrangeByRank(key, start, end);
} }
public Integer zremrangeByScore(String key, double start, double end) { public Integer zremrangeByScore(String key, double start, double end) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.zremrangeByScore(key, start, end); return j.zremrangeByScore(key, start, end);
} }
public Integer linsert(String key, LIST_POSITION where, String pivot, public Integer linsert(String key, LIST_POSITION where, String pivot,
String value) { String value) {
Jedis j = getShard(key); Jedis j = getShard(key);
return j.linsert(key, where, pivot, value); return j.linsert(key, where, pivot, value);
} }
public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
shardedJedisPipeline.setShardedJedis(this);
shardedJedisPipeline.execute();
return shardedJedisPipeline.getResults();
}
} }

437
src/main/java/redis/clients/jedis/ShardedJedisPipeline.java Normal file
View File

@@ -0,0 +1,437 @@
package redis.clients.jedis;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import redis.clients.jedis.Client.LIST_POSITION;
public abstract class ShardedJedisPipeline {
private ShardedJedis jedis;
private List<FutureResult> results = new ArrayList<FutureResult>();
private class FutureResult {
private Client client;
public FutureResult(Client client) {
this.client = client;
}
public Object get() {
return client.getOne();
}
}
public void setShardedJedis(ShardedJedis jedis) {
this.jedis = jedis;
}
protected void set(String key, String value) {
Client c = jedis.getShard(key).getClient();
c.set(key, value);
results.add(new FutureResult(c));
}
protected void get(String key) {
Client c = jedis.getShard(key).getClient();
c.get(key);
results.add(new FutureResult(c));
}
protected void exists(String key) {
Client c = jedis.getShard(key).getClient();
c.exists(key);
results.add(new FutureResult(c));
}
protected void type(String key) {
Client c = jedis.getShard(key).getClient();
c.type(key);
results.add(new FutureResult(c));
}
protected void expire(String key, int seconds) {
Client c = jedis.getShard(key).getClient();
c.expire(key, seconds);
results.add(new FutureResult(c));
}
protected void expireAt(String key, long unixTime) {
Client c = jedis.getShard(key).getClient();
c.expireAt(key, unixTime);
results.add(new FutureResult(c));
}
protected void ttl(String key) {
Client c = jedis.getShard(key).getClient();
c.ttl(key);
results.add(new FutureResult(c));
}
protected void getSet(String key, String value) {
Client c = jedis.getShard(key).getClient();
c.getSet(key, value);
results.add(new FutureResult(c));
}
protected void setnx(String key, String value) {
Client c = jedis.getShard(key).getClient();
c.setnx(key, value);
results.add(new FutureResult(c));
}
protected void setex(String key, int seconds, String value) {
Client c = jedis.getShard(key).getClient();
c.setex(key, seconds, value);
results.add(new FutureResult(c));
}
protected void decrBy(String key, int integer) {
Client c = jedis.getShard(key).getClient();
c.decrBy(key, integer);
results.add(new FutureResult(c));
}
protected void decr(String key) {
Client c = jedis.getShard(key).getClient();
c.decr(key);
results.add(new FutureResult(c));
}
protected void incrBy(String key, int integer) {
Client c = jedis.getShard(key).getClient();
c.incrBy(key, integer);
results.add(new FutureResult(c));
}
protected void incr(String key) {
Client c = jedis.getShard(key).getClient();
c.incr(key);
results.add(new FutureResult(c));
}
protected void append(String key, String value) {
Client c = jedis.getShard(key).getClient();
c.append(key, value);
results.add(new FutureResult(c));
}
protected void substr(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.substr(key, start, end);
results.add(new FutureResult(c));
}
protected void hset(String key, String field, String value) {
Client c = jedis.getShard(key).getClient();
c.hset(key, field, value);
results.add(new FutureResult(c));
}
protected void hget(String key, String field) {
Client c = jedis.getShard(key).getClient();
c.hget(key, field);
results.add(new FutureResult(c));
}
protected void hsetnx(String key, String field, String value) {
Client c = jedis.getShard(key).getClient();
c.hsetnx(key, field, value);
results.add(new FutureResult(c));
}
protected void hmset(String key, Map<String, String> hash) {
Client c = jedis.getShard(key).getClient();
c.hmset(key, hash);
results.add(new FutureResult(c));
}
protected void hmget(String key, String... fields) {
Client c = jedis.getShard(key).getClient();
c.hmget(key, fields);
results.add(new FutureResult(c));
}
protected void hincrBy(String key, String field, int value) {
Client c = jedis.getShard(key).getClient();
c.hincrBy(key, field, value);
results.add(new FutureResult(c));
}
protected void hexists(String key, String field) {
Client c = jedis.getShard(key).getClient();
c.hexists(key, field);
results.add(new FutureResult(c));
}
protected void hdel(String key, String field) {
Client c = jedis.getShard(key).getClient();
c.hdel(key, field);
results.add(new FutureResult(c));
}
protected void hlen(String key) {
Client c = jedis.getShard(key).getClient();
c.hlen(key);
results.add(new FutureResult(c));
}
protected void hkeys(String key) {
Client c = jedis.getShard(key).getClient();
c.hkeys(key);
results.add(new FutureResult(c));
}
protected void hvals(String key) {
Client c = jedis.getShard(key).getClient();
c.hvals(key);
results.add(new FutureResult(c));
}
protected void hgetAll(String key) {
Client c = jedis.getShard(key).getClient();
c.hgetAll(key);
results.add(new FutureResult(c));
}
protected void rpush(String key, String string) {
Client c = jedis.getShard(key).getClient();
c.rpush(key, string);
results.add(new FutureResult(c));
}
protected void lpush(String key, String string) {
Client c = jedis.getShard(key).getClient();
c.lpush(key, string);
results.add(new FutureResult(c));
}
protected void llen(String key) {
Client c = jedis.getShard(key).getClient();
c.llen(key);
results.add(new FutureResult(c));
}
protected void lrange(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.lrange(key, start, end);
results.add(new FutureResult(c));
}
protected void ltrim(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.ltrim(key, start, end);
results.add(new FutureResult(c));
}
protected void lindex(String key, int index) {
Client c = jedis.getShard(key).getClient();
c.lindex(key, index);
results.add(new FutureResult(c));
}
protected void lset(String key, int index, String value) {
Client c = jedis.getShard(key).getClient();
c.lset(key, index, value);
results.add(new FutureResult(c));
}
protected void lrem(String key, int count, String value) {
Client c = jedis.getShard(key).getClient();
c.lrem(key, count, value);
results.add(new FutureResult(c));
}
protected void lpop(String key) {
Client c = jedis.getShard(key).getClient();
c.lpop(key);
results.add(new FutureResult(c));
}
protected void rpop(String key) {
Client c = jedis.getShard(key).getClient();
c.rpop(key);
results.add(new FutureResult(c));
}
protected void sadd(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.sadd(key, member);
results.add(new FutureResult(c));
}
protected void smembers(String key) {
Client c = jedis.getShard(key).getClient();
c.smembers(key);
results.add(new FutureResult(c));
}
protected void srem(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.srem(key, member);
results.add(new FutureResult(c));
}
protected void spop(String key) {
Client c = jedis.getShard(key).getClient();
c.spop(key);
results.add(new FutureResult(c));
}
protected void scard(String key) {
Client c = jedis.getShard(key).getClient();
c.scard(key);
results.add(new FutureResult(c));
}
protected void sismember(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.sismember(key, member);
results.add(new FutureResult(c));
}
protected void srandmember(String key) {
Client c = jedis.getShard(key).getClient();
c.srandmember(key);
results.add(new FutureResult(c));
}
protected void zadd(String key, double score, String member) {
Client c = jedis.getShard(key).getClient();
c.zadd(key, score, member);
results.add(new FutureResult(c));
}
protected void zrange(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.zrange(key, start, end);
results.add(new FutureResult(c));
}
protected void zrem(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.zrem(key, member);
results.add(new FutureResult(c));
}
protected void zincrby(String key, double score, String member) {
Client c = jedis.getShard(key).getClient();
c.zincrby(key, score, member);
results.add(new FutureResult(c));
}
protected void zrank(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.zrank(key, member);
results.add(new FutureResult(c));
}
protected void zrevrank(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.zrevrank(key, member);
results.add(new FutureResult(c));
}
protected void zrevrange(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.zrevrange(key, start, end);
results.add(new FutureResult(c));
}
protected void zrangeWithScores(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.zrangeWithScores(key, start, end);
results.add(new FutureResult(c));
}
protected void zrevrangeWithScores(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.zrevrangeWithScores(key, start, end);
results.add(new FutureResult(c));
}
protected void zcard(String key) {
Client c = jedis.getShard(key).getClient();
c.zcard(key);
results.add(new FutureResult(c));
}
protected void zscore(String key, String member) {
Client c = jedis.getShard(key).getClient();
c.zscore(key, member);
results.add(new FutureResult(c));
}
protected void sort(String key) {
Client c = jedis.getShard(key).getClient();
c.sort(key);
results.add(new FutureResult(c));
}
protected void sort(String key, SortingParams sortingParameters) {
Client c = jedis.getShard(key).getClient();
c.sort(key, sortingParameters);
results.add(new FutureResult(c));
}
protected void zcount(String key, double min, double max) {
Client c = jedis.getShard(key).getClient();
c.zcount(key, min, max);
results.add(new FutureResult(c));
}
protected void zrangeByScore(String key, double min, double max) {
Client c = jedis.getShard(key).getClient();
c.zrangeByScore(key, min, max);
results.add(new FutureResult(c));
}
protected void zrangeByScore(String key, double min, double max,
int offset, int count) {
Client c = jedis.getShard(key).getClient();
c.zrangeByScore(key, min, max, offset, count);
results.add(new FutureResult(c));
}
protected void zrangeByScoreWithScores(String key, double min, double max) {
Client c = jedis.getShard(key).getClient();
c.zrangeByScoreWithScores(key, min, max);
results.add(new FutureResult(c));
}
protected void zrangeByScoreWithScores(String key, double min, double max,
int offset, int count) {
Client c = jedis.getShard(key).getClient();
c.zrangeByScoreWithScores(key, min, max, offset, count);
results.add(new FutureResult(c));
}
protected void zremrangeByRank(String key, int start, int end) {
Client c = jedis.getShard(key).getClient();
c.zremrangeByRank(key, start, end);
results.add(new FutureResult(c));
}
protected void zremrangeByScore(String key, double start, double end) {
Client c = jedis.getShard(key).getClient();
c.zremrangeByScore(key, start, end);
results.add(new FutureResult(c));
}
protected void linsert(String key, LIST_POSITION where, String pivot,
String value) {
Client c = jedis.getShard(key).getClient();
c.linsert(key, where, pivot, value);
results.add(new FutureResult(c));
}
public List<Object> getResults() {
List<Object> r = new ArrayList<Object>();
for (FutureResult fr : results) {
r.add(fr.get());
}
return r;
}
public abstract void execute();
}

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

@@ -10,112 +10,138 @@ import org.junit.Test;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo; import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis; import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.tests.HostAndPortUtil.HostAndPort; import redis.clients.jedis.tests.HostAndPortUtil.HostAndPort;
import redis.clients.util.Hashing; import redis.clients.util.Hashing;
public class ShardedJedisTest extends Assert { public class ShardedJedisTest extends Assert {
private static HostAndPort redis1 = HostAndPortUtil.getRedisServers() private static HostAndPort redis1 = HostAndPortUtil.getRedisServers()
.get(0); .get(0);
private static HostAndPort redis2 = HostAndPortUtil.getRedisServers() private static HostAndPort redis2 = HostAndPortUtil.getRedisServers()
.get(1); .get(1);
@Test @Test
public void checkSharding() throws IOException { public void checkSharding() throws IOException {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.host, redis1.port)); shards.add(new JedisShardInfo(redis1.host, redis1.port));
shards.add(new JedisShardInfo(redis2.host, redis2.port)); shards.add(new JedisShardInfo(redis2.host, redis2.port));
ShardedJedis jedis = new ShardedJedis(shards); ShardedJedis jedis = new ShardedJedis(shards);
JedisShardInfo s1 = jedis.getShardInfo("a"); JedisShardInfo s1 = jedis.getShardInfo("a");
JedisShardInfo s2 = jedis.getShardInfo("b"); JedisShardInfo s2 = jedis.getShardInfo("b");
assertNotSame(s1, s2); assertNotSame(s1, s2);
} }
@Test @Test
public void trySharding() throws IOException { public void trySharding() throws IOException {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo si = new JedisShardInfo(redis1.host, redis1.port); JedisShardInfo si = new JedisShardInfo(redis1.host, redis1.port);
si.setPassword("foobared"); si.setPassword("foobared");
shards.add(si); shards.add(si);
si = new JedisShardInfo(redis2.host, redis2.port); si = new JedisShardInfo(redis2.host, redis2.port);
si.setPassword("foobared"); si.setPassword("foobared");
shards.add(si); shards.add(si);
ShardedJedis jedis = new ShardedJedis(shards); ShardedJedis jedis = new ShardedJedis(shards);
jedis.set("a", "bar"); jedis.set("a", "bar");
JedisShardInfo s1 = jedis.getShardInfo("a"); JedisShardInfo s1 = jedis.getShardInfo("a");
jedis.set("b", "bar1"); jedis.set("b", "bar1");
JedisShardInfo s2 = jedis.getShardInfo("b"); JedisShardInfo s2 = jedis.getShardInfo("b");
jedis.disconnect(); jedis.disconnect();
Jedis j = new Jedis(s1.getHost(), s1.getPort()); Jedis j = new Jedis(s1.getHost(), s1.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar", j.get("a")); assertEquals("bar", j.get("a"));
j.disconnect(); j.disconnect();
j = new Jedis(s2.getHost(), s2.getPort()); j = new Jedis(s2.getHost(), s2.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar1", j.get("b")); assertEquals("bar1", j.get("b"));
j.disconnect(); j.disconnect();
} }
@Test @Test
public void tryShardingWithMurmure() throws IOException { public void tryShardingWithMurmure() throws IOException {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo si = new JedisShardInfo(redis1.host, redis1.port); JedisShardInfo si = new JedisShardInfo(redis1.host, redis1.port);
si.setPassword("foobared"); si.setPassword("foobared");
shards.add(si); shards.add(si);
si = new JedisShardInfo(redis2.host, redis2.port); si = new JedisShardInfo(redis2.host, redis2.port);
si.setPassword("foobared"); si.setPassword("foobared");
shards.add(si); shards.add(si);
ShardedJedis jedis = new ShardedJedis(shards, Hashing.MURMUR_HASH); ShardedJedis jedis = new ShardedJedis(shards, Hashing.MURMUR_HASH);
jedis.set("a", "bar"); jedis.set("a", "bar");
JedisShardInfo s1 = jedis.getShardInfo("a"); JedisShardInfo s1 = jedis.getShardInfo("a");
jedis.set("b", "bar1"); jedis.set("b", "bar1");
JedisShardInfo s2 = jedis.getShardInfo("b"); JedisShardInfo s2 = jedis.getShardInfo("b");
jedis.disconnect(); jedis.disconnect();
Jedis j = new Jedis(s1.getHost(), s1.getPort()); Jedis j = new Jedis(s1.getHost(), s1.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar", j.get("a")); assertEquals("bar", j.get("a"));
j.disconnect(); j.disconnect();
j = new Jedis(s2.getHost(), s2.getPort()); j = new Jedis(s2.getHost(), s2.getPort());
j.auth("foobared"); j.auth("foobared");
assertEquals("bar1", j.get("b")); assertEquals("bar1", j.get("b"));
j.disconnect(); j.disconnect();
} }
@Test @Test
public void checkKeyTags() { public void checkKeyTags() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.host, redis1.port)); shards.add(new JedisShardInfo(redis1.host, redis1.port));
shards.add(new JedisShardInfo(redis2.host, redis2.port)); shards.add(new JedisShardInfo(redis2.host, redis2.port));
ShardedJedis jedis = new ShardedJedis(shards, ShardedJedis jedis = new ShardedJedis(shards,
ShardedJedis.DEFAULT_KEY_TAG_PATTERN); ShardedJedis.DEFAULT_KEY_TAG_PATTERN);
assertEquals(jedis.getKeyTag("foo"), "foo"); assertEquals(jedis.getKeyTag("foo"), "foo");
assertEquals(jedis.getKeyTag("foo{bar}"), "bar"); assertEquals(jedis.getKeyTag("foo{bar}"), "bar");
assertEquals(jedis.getKeyTag("foo{bar}}"), "bar"); // default pattern is assertEquals(jedis.getKeyTag("foo{bar}}"), "bar"); // default pattern is
// non greedy // non greedy
assertEquals(jedis.getKeyTag("{bar}foo"), "bar"); // Key tag may appear assertEquals(jedis.getKeyTag("{bar}foo"), "bar"); // Key tag may appear
// anywhere // anywhere
assertEquals(jedis.getKeyTag("f{bar}oo"), "bar"); // Key tag may appear assertEquals(jedis.getKeyTag("f{bar}oo"), "bar"); // Key tag may appear
// anywhere // anywhere
JedisShardInfo s1 = jedis.getShardInfo("abc{bar}"); JedisShardInfo s1 = jedis.getShardInfo("abc{bar}");
JedisShardInfo s2 = jedis.getShardInfo("foo{bar}"); JedisShardInfo s2 = jedis.getShardInfo("foo{bar}");
assertSame(s1, s2); assertSame(s1, s2);
JedisShardInfo s3 = jedis.getShardInfo("a"); JedisShardInfo s3 = jedis.getShardInfo("a");
JedisShardInfo s4 = jedis.getShardInfo("b"); JedisShardInfo s4 = jedis.getShardInfo("b");
assertNotSame(s3, s4); assertNotSame(s3, s4);
ShardedJedis jedis2 = new ShardedJedis(shards); ShardedJedis jedis2 = new ShardedJedis(shards);
assertEquals(jedis2.getKeyTag("foo"), "foo"); assertEquals(jedis2.getKeyTag("foo"), "foo");
assertNotSame(jedis2.getKeyTag("foo{bar}"), "bar"); assertNotSame(jedis2.getKeyTag("foo{bar}"), "bar");
JedisShardInfo s5 = jedis2.getShardInfo("foo{bar}"); JedisShardInfo s5 = jedis2.getShardInfo("foo{bar}");
JedisShardInfo s6 = jedis2.getShardInfo("abc{bar}"); JedisShardInfo s6 = jedis2.getShardInfo("abc{bar}");
assertNotSame(s5, s6); assertNotSame(s5, s6);
}
@Test
public void shardedPipeline() {
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(redis1.host, redis1.port));
shards.add(new JedisShardInfo(redis2.host, redis2.port));
shards.get(0).setPassword("foobared");
shards.get(1).setPassword("foobared");
ShardedJedis jedis = new ShardedJedis(shards);
jedis.set("a", "a");
jedis.set("b", "b");
assertTrue(!jedis.getShard("a").equals(jedis.getShard("b")));
List<Object> results = jedis.pipelined(new ShardedJedisPipeline() {
public void execute() {
get("a");
get("b");
}
});
assertEquals("a", results.get(0));
assertEquals("b", results.get(1));
} }
} }