Jedis Cluster

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Cluster

package application;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javafx.geometry.Insets;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.VBox;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.ShardedJedisPool;

public class Cluster {
	JedisCluster cluster = null;
	
	Button setBtn = new Button("SET");
	Button setAsyncBtn = new Button("Async SET");
	Button msetBtn = new Button("MSET");
	Button mgetBtn = new Button("MGET");
	Button keysBtn = new Button("KEYS");
	Button dbsizeBtn = new Button("DBSIZE");
	Button pipelineSetBtn = new Button("Pipeline SET");
	Button reloadBtn = new Button("Reload");
	Button shutdownBtn = new Button("SHUTDOWN");
	
	Button clusterCountKeysInSlotBtn = new Button("CLUSTERCOUNTKEYSINSLOT");
	String key = "keyX";
	int idx = 0;

	Cluster(VBox vbox) {
		String host = "192.168.56.103";
		int port1 = 7001;
		int port2 = 7005;
		
		Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
		//Jedis Cluster will attempt to discover cluster nodes automatically
		jedisClusterNodes.add(new HostAndPort(host, port1));
		jedisClusterNodes.add(new HostAndPort(host, port2));
		try {
			// cluster를 사용하려면 commons-pool2-2.4.2.jar를 포함해야 한다. 그렇지 않으면 class not found 에러가 난다.
			cluster = new JedisCluster(jedisClusterNodes);
			cluster.set("key", "Hello Jedis Cluster");
			String value = cluster.get("key");
			System.out.println(value);
		} catch (Exception e) {
			System.out.println(e);
			return;
		}
		
		GridPane gridpane = new GridPane();
	    gridpane.setPadding(new Insets(5));
	    gridpane.setHgap(5);
	    gridpane.setVgap(5);
	    vbox.getChildren().add(gridpane);

	    Label lbl = new Label("Cluster");

		gridpane.add(lbl, 0, 1);
		gridpane.add(setBtn, 1, 1);
		gridpane.add(setAsyncBtn, 2, 1);
		gridpane.add(msetBtn, 3, 1);
		gridpane.add(mgetBtn, 4, 1);
		gridpane.add(keysBtn, 5, 1);
		gridpane.add(dbsizeBtn, 1, 2);
		gridpane.add(pipelineSetBtn, 2, 2);
		gridpane.add(clusterCountKeysInSlotBtn, 3, 2);
		gridpane.add(reloadBtn, 4, 2);
		gridpane.add(shutdownBtn, 5, 2);	

		setBtn.setOnAction(e->{  set();	});
		setAsyncBtn.setOnAction(e->{  asyncSet();	});
		msetBtn.setOnAction(e->{  mset();	});
		mgetBtn.setOnAction(e->{  mget();	});
		keysBtn.setOnAction(e->{  keys();	});
		dbsizeBtn.setOnAction(e->{  dbsize();	});
		pipelineSetBtn.setOnAction(e->{  pipelineSet();	});
		clusterCountKeysInSlotBtn.setOnAction(e->{  clusterCountKeysInSlot();	});
		shutdownBtn.setOnAction(e->{  clusterShutdown();	});
		
		reloadBtn.setOnAction(e->{  
			//redisCluster.reloadPartitions();
		});

	}
	
	protected void set() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("set");
		long loop = 1000;
		long start = System.currentTimeMillis(); 
		for (int i=idx; i<(idx+loop); i++) {
			try {
				String ret = cluster.set(key+i, "value"+i);
				System.out.println("set "+key+i+" value"+i+" -> "+ret+" "+(System.currentTimeMillis()/1000));
			} catch (Exception e) {
				System.out.println(e);
			}
		}
		idx += loop;
		System.out.println("set elapsed time(ms) -> "+(System.currentTimeMillis() - start)); 
	}

	protected void asyncSet() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("Async 명령 없음.");
	}

	protected void mset() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("mset");
		long start = System.currentTimeMillis(); 
		try {
			String ret = cluster.mset(key+1, "value1", key+2, "value2", key+3, "value3", key+4, "value4"); 
			// redis.clients.jedis.exceptions.JedisClusterException: No way to dispatch this command to Redis Cluster because keys have different slots.
			System.out.println("mset -> "+ret);
		} catch (Exception e) {
			System.out.println(e);
		}
		System.out.println("mset elapsed time(ms) -> "+(System.currentTimeMillis() - start)); 
	}
	
	protected void mget() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("mget");
		String key = "key";
		String keys[ ] = new String[10];
		int idx = 0;
		try {
			for (int i=0; i<10; i++) {
				keys[i] = key+idx;
				idx++;
			}
			List<String> ret = cluster.mget(keys);
			// redis.clients.jedis.exceptions.JedisClusterException: No way to dispatch this command to Redis Cluster because keys have different slots.
			System.out.println(ret.toString());
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	protected void keys() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("keys -> 해당 메소드 없음.");
		try {
		} catch (Exception e) {
			System.out.println(e);
		}
	}
	
	protected void dbsize() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("dbsize -> deprecated");
		try {
			Long dbsize = cluster.dbSize();		// deprecated
			// redis.clients.jedis.exceptions.JedisClusterException: No way to dispatch this command to Redis Cluster.
			System.out.println("dbsize -> "+dbsize);
		} catch (Exception e) {
			System.out.println(e);
		}
	}
	
	protected void pipelineSet() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("Cluster Pipeline set -> Cluster에서 Pipeline 사용할 수 없음.");
		long start = System.currentTimeMillis(); 
		try {
		} catch (Exception e) {
			System.out.println(e);
		}
		System.out.println("Cluster Pipeline set elapsed time(ms) -> "+(System.currentTimeMillis() - start)); 
	}
	
	// CLUSTER COUNTKEYSINSLOT slot -> return Long
	protected void clusterCountKeysInSlot() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("CLUSTER COUNTKEYSINSLOT slot -> 해당 메소드 없음.");
		try {
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	// SHUTDOWN -> 클러스터 내 모든 노드를 shutdown한다. True -> save rdb
	protected void clusterShutdown() {
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("SHUTDOWN -> deprecated");
		try {
			cluster.shutdown();	// deprecated
			// redis.clients.jedis.exceptions.JedisClusterException: No way to dispatch this command to Redis Cluster.
		} catch (Exception e) {
			System.out.println(e);
		}
	}
}

Cluster Commands

Jedis Cluster Commands

Cluster Meet -> Simply string reply.
Cluster Forget -> Simply string reply.
Cluster AddSlots -> Simply string reply.
Cluster DelSlots -> Simply string reply.
Cluster Info -> Bulk string reply.
Cluster Nodes -> Bulk string reply.
Cluster Replicate -> Simply string reply.
Cluster Slaves -> Array(List<String>) reply.
Cluster Keyslot -> Integer reply.
Cluster CountKeysInSlot -> Integer reply.
Cluster GetKeysInSlot -> Array(List<String>) reply.
Cluster SetSlot -> Simply string reply.
Cluster Slots -> 3 Nested array(List<Object>) reply.
Cluster Failover -> Simply string reply.
Cluster Count-Failure-Reports -> 해당 메소드 없음.
Cluster Reset -> Simply string reply.
Cluster SaveConfig -> Simply string reply.
Cluster Set-Config-Epoch -> 해당 메소드 없음.
Cluster ReadOnly -> Simply string reply.
Cluster ReadWrite -> 해당 메소드 없음.

Cluster Meet

// CLUSTER MEET ip port -> Simply string reply
protected void clusterMeet() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER MEET ip port -> Simply string reply");
	String ret = null;
	int port = 7002;
	try {
		ret = redis.clusterMeet(host, port);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster meet "+host+" "+port+" -> "+ret);
}

Cluster Forget

// CLUSTER FORGET nodeId -> Simply string reply
protected void clusterForget() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER FORGET nodeid -> Simply string reply");
	String ret = null;
	String nodeId = "xxxxxxxxxxxxxx";
	try {
		ret = redis.clusterForget(nodeId);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster forget "+nodeId+" -> "+ret);
}

Cluster AddSlots

// CLUSTER ADDSLOTS slot [slot ...] -> Simply string reply
protected void clusterAddSlots() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER ADDSLOTS slot [slot ...] -> Simply string reply");
	String ret = null;
	int slot = 0;
	try {
		ret = redis.clusterAddSlots(slot);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster addslots "+slot+" -> "+ret);
}

Cluster DelSlots

// CLUSTER DELSLOTS slot [slot ...] -> Simply string reply
protected void clusterDelSlots() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER DELSLOTS slot [slot ...] -> Simply string reply");
	String ret = null;
	int slot = 0;
	try {
		ret = redis.clusterDelSlots(slot);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster delslots "+slot+" -> "+ret);
}

Cluster Info

// CLUSTER INFO -> Bulk string reply
protected void clusterInfo() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER INFO -> Bulk string reply");
	String ret = null;
	try {
		ret = redis.clusterInfo();
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster info -> ");
	System.out.println(ret);
}

Cluster Nodes

// CLUSTER NODES -> Bulk string reply
protected void clusterNodes() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER NODES -> Bulk string reply");
	String ret = null;
	try {
		ret = redis.clusterNodes();
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster nodes -> ");
	System.out.println(ret);
}

Cluster Replicate

// CLUSTER REPLICATE -> Simple string reply
protected void clusterReplicate() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER REPLICATE -> Simple string reply");
	String nodeId = "xxxxxxxxxxxxxx";
	String ret = null;
	try {
		ret = redis.clusterReplicate(nodeId);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster replicate -> "+ret);
}

Cluster Slaves

// CLUSTER SLAVES -> Array reply
protected void clusterSalves() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER SLAVES -> List<String>");
	String nodeId = "95f485be27ef3fcf0e9a2bae6005fdecfa981c8b";
	List<String> list = null;
	try {
		list = redis.clusterSlaves(nodeId);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster slaves -> "+list.size());
	ListIterator<String> itr=list.listIterator();
	while(itr.hasNext()){  
		System.out.println(itr.next());  
	}  
}

Cluster Keyslot

// CLUSTER KEYSLOT slot -> integer
protected void clusterKeySlot() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER KEYSLOT slot -> long.");
	String key = "key";
	long ret = 0;
	try {
		ret = redis.clusterKeySlot(key);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster keyslot "+key+" -> "+ret);
}

Cluster CountKeysInSlot

// CLUSTER COUNTKEYSINSLOT slot -> integer
protected void clusterCountKeysInSlot() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER COUNTKEYSINSLOT slot -> long");
	int slot = 0;
	long ret = 0;
	try {
		ret = redis.clusterCountKeysInSlot(slot);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster countkeysinslot "+slot+" -> "+ret);
}

Cluster GetKeysInSlot

// CLUSTER GETKEYSINSLOT slot count -> array reply.
protected void clusterGetKeysInSlot() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER GETKEYSINSLOT slot count -> List<String>");
	int slot = 0;
	List<String> list;
	try {
		list = redis.clusterGetKeysInSlot(slot, 10);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster countkeysinslot "+slot+" -> "+list.size());
	ListIterator<String> itr=list.listIterator();
	while(itr.hasNext()){  
		System.out.println(itr.next());  
	}  
}

Cluster SetSlot

// CLUSTER SETSLOT slot MIGRATING|IMPORTING|STABLE|NODE [node-id] -> Simple string reply.
protected void clusterSetSlot() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER SETSLOT slot MIGRATING|IMPORTING|STABLE|NODE [node-id] -> Simple string reply.");
	int slot = 0;
	String ret;
	String nodeId = "95f485be27ef3fcf0e9a2bae6005fdecfa981c8b";
	// MIGRATING
	try {
		ret = redis.clusterSetSlotMigrating(slot, nodeId);
		System.out.println("cluster setslot "+slot+" migrating "+nodeId +" -> "+ret);
	} catch (Exception e) {
		System.out.println("cluster setslot "+slot+" migrating "+nodeId +" -> ");
		System.out.println(e);
	}
	// IMPORTING
	try {
		ret = redis.clusterSetSlotImporting(slot, nodeId);
		System.out.println("cluster setslot "+slot+" importing "+nodeId +" -> "+ret);
	} catch (Exception e) {
		System.out.println("cluster setslot "+slot+" importing "+nodeId +" -> ");
		System.out.println(e);
	}
	// STABLE
	try {
		ret = redis.clusterSetSlotStable(slot);
		System.out.println("cluster setslot "+slot+" -> "+ret);
	} catch (Exception e) {
		System.out.println("cluster setslot "+slot+" -> ");
		System.out.println(e);
	}
	// NODE
	try {
		ret = redis.clusterSetSlotNode(slot, nodeId);
		System.out.println("cluster setslot "+slot+" node "+nodeId+" -> "+ret);
	} catch (Exception e) {
		System.out.println("cluster setslot "+slot+" node "+nodeId+" -> ");
		System.out.println(e);
	}	
}

Cluster Slots

// CLUSTER SLOTS -> 3 Nested array reply.
protected void clusterSlots() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER SLOTS -> List<Object>");
	List<Object> list;
	try {
		list = redis.clusterSlots();
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("cluster slots -> "+list.size());
	for (int i=0; i<list.size(); i++) {
		System.out.println(i+". "+list.get(i));
		List<Object> o = (List<Object>) list.get(i);
		for (int j=0; j<o.size(); j++) {
			if (j < 2) {
				System.out.println("  "+j+") "+o.get(j));
			} else {
				List<Object> o2 = (List<Object>) o.get(j);
				for (int k=0; k<o2.size(); k++) {
					System.out.println("    "+k+"> "+o2.get(k));
				}
			}
		}
	}
}

Cluster Failover

// CLUSTER FAILOVER -> Simple string reply.
protected void clusterFailover() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER FAILOVER -> Simple string reply");
	//  [FORCE|TAKEOVER] option에 해당하는 메소드 없음.
	String ret;
	try {
		ret = redis.clusterFailover();
		System.out.println("cluster failover -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

Cluster Count-Failure-Reports -> 해당 메소드 없음

// CLUSTER COUNT-FAILURE-REPORTS -> Simple string reply.
protected void clusterCountFailureReports() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER COUNT-FAILURE-REPORTS -> 해당 메소드 없음.");
	try {
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

Cluster Reset

// CLUSTER RESET -> Simple string reply.
protected void clusterReset() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER RESET -> Simple string reply.");
	String ret;
	try {
		ret = redis.clusterReset(Reset.SOFT);
		System.out.println("cluster reset soft -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	try {
		ret = redis.clusterReset(Reset.HARD);
		System.out.println("cluster reset hard -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

Cluster SaveConfig

// CLUSTER SAVECONFIG -> Simple string reply.
protected void clusterSaveConfig() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER SAVECONFIG -> Simple string reply.");
	String ret;
	try {
		ret = redis.clusterSaveConfig();
		System.out.println("cluster saveconfig -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

Cluster Set-Config-Epoch -> 해당 메소드 없음

// CLUSTER SET-CONFIG-EPOCH -> Simple string reply.
protected void clusterSetConfigEpoch() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER SET-CONFIG-EPOCH -> 해당 메소드 없음.");
	try {
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

Cluster ReadOnly

// READONLY -> Simple string reply.
protected void clusterReadOnly() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER READONLY -> Simple string reply.");
	String ret;
	try {
		ret = redis.readonly();
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
	System.out.println("readonly -> "+ret);
}

Cluster ReadWrite -> 해당 메소드 없음

// READWRITE -> Simple string reply.
protected void clusterReadWrite() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("CLUSTER READWRITE -> 해당 메소드 없음.");
	try {
	} catch (Exception e) {
		System.out.println(e);
		return;
	}
}

<< Sentinel	Jedis Cluster	Sharding >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.