Merge branch 'cluster' of github.com:marcosnils/jedis into marcosnils-cluster

Conflicts:
	src/main/java/redis/clients/jedis/BinaryClient.java
	src/main/java/redis/clients/jedis/Client.java
	src/main/java/redis/clients/jedis/Jedis.java
	src/main/java/redis/clients/jedis/Protocol.java

src/main/java/redis/clients/jedis/BinaryClient.java

@@ -1135,4 +1135,11 @@ public class BinaryClient extends Connection {
     public void waitReplicas(int replicas, long timeout) {
 	sendCommand(WAIT, toByteArray(replicas), toByteArray(timeout));
     }
+
+    public void cluster(final byte[]... args) {
+    	sendCommand(CLUSTER, args);
+    }
+    public void asking() {
+    	sendCommand(Command.ASKING);
+    }
 }

src/main/java/redis/clients/jedis/BinaryJedis.java

@@ -1697,7 +1697,7 @@ public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKey
 
     protected void checkIsInMulti() {
 	if (client.isInMulti()) {
-	    throw new JedisDataException(
+			throw new JedisDataException(
 		    "Cannot use Jedis when in Multi. Please use JedisTransaction instead.");
 	}
     }

src/main/java/redis/clients/jedis/Client.java

@@ -820,4 +820,65 @@ public class Client extends BinaryClient implements Commands {
     public void zscan(final String key, int cursor, final ScanParams params) {
  	zscan(SafeEncoder.encode(key), cursor, params);
     }
+
+    public void cluster(final String subcommand, final int... args) {
+	final byte[][] arg = new byte[args.length+1][];
+	for (int i = 1; i < arg.length; i++) {
+	    arg[i] = toByteArray(args[i-1]);
+	}
+	arg[0] = SafeEncoder.encode(subcommand);
+	cluster(arg);
+    }
+
+    public void cluster(final String subcommand, final String... args) {
+	final byte[][] arg = new byte[args.length+1][];
+	for (int i = 1; i < arg.length; i++) {
+	    arg[i] = SafeEncoder.encode(args[i-1]);
+	}
+	arg[0] = SafeEncoder.encode(subcommand);
+	cluster(arg);
+    }
+    
+    public void cluster(final String subcommand) {
+	final byte[][] arg = new byte[1][];
+	arg[0] = SafeEncoder.encode(subcommand);
+	cluster(arg);
+    }
+    
+    public void clusterNodes() {
+	cluster(Protocol.CLUSTER_NODES);
+    }
+    
+    public void clusterMeet(final String ip, final int port) {
+	cluster(Protocol.CLUSTER_MEET, ip, String.valueOf(port));
+    }
+    
+    public void clusterAddSlots(final int ...slots) {
+	cluster(Protocol.CLUSTER_ADDSLOTS, slots);
+    }
+    
+    public void clusterDelSlots(final int ...slots) {
+	cluster(Protocol.CLUSTER_DELSLOTS, slots);
+    }
+    
+    public void clusterInfo() {
+	cluster(Protocol.CLUSTER_INFO);
+    }
+    
+    public void clusterGetKeysInSlot(final int slot, final int count) {
+    	final int[] args = new int[]{ slot, count };
+    	cluster(Protocol.CLUSTER_GETKEYSINSLOT, args);
+    }
+    
+    public void clusterSetSlotNode(final int slot, final String nodeId) {
+	cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_NODE, nodeId);
+    }
+    
+    public void clusterSetSlotMigrating(final int slot, final String nodeId) {
+	cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_MIGRATING, nodeId);
+    }
+    
+    public void clusterSetSlotImporting(final int slot, final String nodeId) {
+	cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_IMPORTING, nodeId);
+    }
 }

src/main/java/redis/clients/jedis/ClusterCommands.java

@@ -0,0 +1,23 @@
+package redis.clients.jedis;
+
+import java.util.List;
+
+public interface ClusterCommands {
+    String clusterNodes();
+
+    String clusterMeet(final String ip, final int port);
+
+    String clusterAddSlots(final int... slots);
+
+    String clusterDelSlots(final int... slots);
+
+    String clusterInfo();
+
+    List<String> clusterGetKeysInSlot(final int slot, final int count);
+
+    String clusterSetSlotNode(final int slot, final String nodeId);
+
+    String clusterSetSlotMigrating(final int slot, final String nodeId);
+
+    String clusterSetSlotImporting(final int slot, final String nodeId);
+}

src/main/java/redis/clients/jedis/ClusterPipeline.java

@@ -0,0 +1,23 @@
+package redis.clients.jedis;
+
+import java.util.List;
+
+public interface ClusterPipeline {
+    Response<String> clusterNodes();
+
+    Response<String> clusterMeet(final String ip, final int port);
+
+    Response<String> clusterAddSlots(final int... slots);
+
+    Response<String> clusterDelSlots(final int... slots);
+
+    Response<String> clusterInfo();
+
+    Response<List<String>> clusterGetKeysInSlot(final int slot, final int count);
+
+    Response<String> clusterSetSlotNode(final int slot, final String nodeId);
+
+    Response<String> clusterSetSlotMigrating(final int slot, final String nodeId);
+
+    Response<String> clusterSetSlotImporting(final int slot, final String nodeId);
+}

src/main/java/redis/clients/jedis/Jedis.java

@@ -13,8 +13,10 @@ import java.util.Set;
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.util.SafeEncoder;
 import redis.clients.util.Slowlog;
+import java.net.URI;
+import java.util.*;
 
-public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands, BasicCommands {
+public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands, BasicCommands, ClusterCommands {
     public Jedis(final String host) {
 	super(host);
     }
@@ -3153,4 +3155,63 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
 	}
 	return new ScanResult<Tuple>(newcursor, results);
     }
+    public String clusterNodes() {
+    	checkIsInMulti();
+    	client.clusterNodes();
+    	return client.getBulkReply();
+    }
+    
+    public String clusterMeet(final String ip, final int port) {
+    	checkIsInMulti();
+    	client.clusterMeet(ip, port);
+    	return client.getStatusCodeReply();
+    }
+    
+    public String clusterAddSlots(final int ...slots) {
+    	checkIsInMulti();
+    	client.clusterAddSlots(slots);
+    	return client.getStatusCodeReply();
+    }
+    
+    public String clusterDelSlots(final int ...slots) {
+    	checkIsInMulti();
+    	client.clusterDelSlots(slots);
+    	return client.getStatusCodeReply();
+    }
+    
+    public String clusterInfo() {
+    	checkIsInMulti();
+    	client.clusterInfo();
+    	return client.getStatusCodeReply();
+    }
+    
+    public List<String> clusterGetKeysInSlot(final int slot, final int count) {
+    	checkIsInMulti();
+    	client.clusterGetKeysInSlot(slot, count);
+    	return client.getMultiBulkReply();
+    }
+    
+    public String clusterSetSlotNode(final int slot, final String nodeId) {
+    	checkIsInMulti();
+    	client.clusterSetSlotNode(slot, nodeId);
+    	return client.getStatusCodeReply();
+    }
+    
+    public String clusterSetSlotMigrating(final int slot, final String nodeId) {
+    	checkIsInMulti();
+    	client.clusterSetSlotMigrating(slot, nodeId);
+    	return client.getStatusCodeReply();
+    }
+    
+    public String clusterSetSlotImporting(final int slot, final String nodeId) {
+    	checkIsInMulti();
+    	client.clusterSetSlotImporting(slot, nodeId);
+    	return client.getStatusCodeReply();
+    }
+
+	public String asking() {
+		checkIsInMulti();
+    	client.asking();
+    	return client.getStatusCodeReply();
+	}
 }

src/main/java/redis/clients/jedis/JedisClusterCommand.java

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

src/main/java/redis/clients/jedis/JedisClusterConnectionHandler.java

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

src/main/java/redis/clients/jedis/JedisPool.java

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

src/main/java/redis/clients/jedis/JedisRandomConnectionHandler.java

@@ -0,0 +1,20 @@
+package redis.clients.jedis;
+
+import java.util.Set;
+
+public class JedisRandomConnectionHandler extends JedisClusterConnectionHandler {
+
+	
+	public JedisRandomConnectionHandler(Set<HostAndPort> nodes) {
+		super(nodes);
+	}
+
+	public Jedis getConnection() {
+		return getRandomConnection().getResource();
+	}
+
+	@Override
+	Jedis getConnectionFromSlot(int slot) {
+		return getRandomConnection().getResource();
+	}
+}

src/main/java/redis/clients/jedis/JedisSlotBasedConnectionHandler.java

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

src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java

@@ -7,7 +7,8 @@ import java.util.Set;
 abstract class MultiKeyPipelineBase extends PipelineBase implements
         BasicRedisPipeline,
         MultiKeyBinaryRedisPipeline,
-        MultiKeyCommandsPipeline {
+        MultiKeyCommandsPipeline,
+        ClusterPipeline {
 
     protected Client client = null;
 
@@ -398,4 +399,49 @@ abstract class MultiKeyPipelineBase extends PipelineBase implements
         client.bitop(op, destKey, srcKeys);
         return getResponse(BuilderFactory.LONG);
     }
+    
+    public Response<String> clusterNodes() {
+	client.clusterNodes();
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterMeet(final String ip, final int port) {
+	client.clusterMeet(ip, port);
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterAddSlots(final int... slots) {
+	client.clusterAddSlots(slots);
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterDelSlots(final int... slots) {
+	client.clusterDelSlots(slots);
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterInfo() {
+	client.clusterInfo();
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<List<String>> clusterGetKeysInSlot(final int slot, final int count) {
+	client.clusterGetKeysInSlot(slot, count);
+	return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<String> clusterSetSlotNode(final int slot, final String nodeId) {
+	client.clusterSetSlotNode(slot, nodeId);
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterSetSlotMigrating(final int slot, final String nodeId) {
+	client.clusterSetSlotMigrating(slot, nodeId);
+	return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> clusterSetSlotImporting(final int slot, final String nodeId) {
+	client.clusterSetSlotImporting(slot, nodeId);
+	return getResponse(BuilderFactory.STRING);
+    }
 }

src/main/java/redis/clients/jedis/Protocol.java

@@ -4,15 +4,19 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
+import redis.clients.jedis.exceptions.JedisAskDataException;
 import redis.clients.jedis.exceptions.JedisConnectionException;
 import redis.clients.jedis.exceptions.JedisDataException;
+import redis.clients.jedis.exceptions.JedisMovedDataException;
 import redis.clients.util.RedisInputStream;
 import redis.clients.util.RedisOutputStream;
 import redis.clients.util.SafeEncoder;
 
 public final class Protocol {
 
-    public static final int DEFAULT_PORT = 6379;
+    private static final String ASK_RESPONSE = "ASK";
+    private static final String MOVED_RESPONSE = "MOVED";
+	public static final int DEFAULT_PORT = 6379;
     public static final int DEFAULT_SENTINEL_PORT = 26379;
     public static final int DEFAULT_TIMEOUT = 2000;
     public static final int DEFAULT_DATABASE = 0;
@@ -30,6 +34,17 @@ public final class Protocol {
     public static final String SENTINEL_RESET = "reset";
     public static final String SENTINEL_SLAVES = "slaves";
 
+    public static final String CLUSTER_NODES = "nodes";
+    public static final String CLUSTER_MEET = "meet";
+    public static final String CLUSTER_ADDSLOTS = "addslots";
+    public static final String CLUSTER_DELSLOTS = "delslots";
+    public static final String CLUSTER_INFO = "info";
+    public static final String CLUSTER_GETKEYSINSLOT = "getkeysinslot";
+    public static final String CLUSTER_SETSLOT = "setslot";
+    public static final String CLUSTER_SETSLOT_NODE = "node";
+    public static final String CLUSTER_SETSLOT_MIGRATING = "migrating";
+    public static final String CLUSTER_SETSLOT_IMPORTING = "importing";
+    
     private Protocol() {
 	// this prevent the class from instantiation
     }
@@ -61,8 +76,28 @@ public final class Protocol {
     }
 
     private static void processError(final RedisInputStream is) {
-	String message = is.readLine();
-	throw new JedisDataException(message);
+		String message = is.readLine();
+		//TODO: I'm not sure if this is the best way to do this. 
+		//Maybe Read only first 5 bytes instead?
+		//
+		if (message.contains(MOVED_RESPONSE)) {
+			String[] movedInfo = parseTargetHostAndSlot(message);
+			throw new JedisMovedDataException(message, new HostAndPort(movedInfo[1], Integer.valueOf(movedInfo[2])), Integer.valueOf(movedInfo[0]));
+		} else if (message.contains(ASK_RESPONSE)) {
+			String[] askInfo = parseTargetHostAndSlot(message);
+			throw new JedisAskDataException(message, new HostAndPort(askInfo[1], Integer.valueOf(askInfo[2])), Integer.valueOf(askInfo[0]));
+		}
+		throw new JedisDataException(message);
+    }
+    
+    private static String[] parseTargetHostAndSlot(String clusterRedirectResponse) {
+    	String[] response = new String[3];
+    	String[] messageInfo = clusterRedirectResponse.split(" ");
+    	String[] targetHostAndPort = messageInfo[2].split(":");
+    	response[0] = messageInfo[1];
+    	response[1] = targetHostAndPort[0];
+    	response[2] = targetHostAndPort[1];  	
+    	return response;
     }
 
     private static Object process(final RedisInputStream is) {
@@ -157,8 +192,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, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL, 
-	DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT, SCAN, HSCAN, SSCAN, ZSCAN, WAIT;
+	PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL, DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT, SCAN, HSCAN, SSCAN, ZSCAN, WAIT, CLUSTER, ASKING;
 
 	public final byte[] raw;
 

src/main/java/redis/clients/jedis/exceptions/JedisAskDataException.java

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

src/main/java/redis/clients/jedis/exceptions/JedisClusterException.java

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

src/main/java/redis/clients/jedis/exceptions/JedisClusterMaxRedirectionsException.java

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

src/main/java/redis/clients/jedis/exceptions/JedisMovedDataException.java

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

src/main/java/redis/clients/jedis/exceptions/JedisRedirectionException.java

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