RScript.scriptExists fixed

redisson · Jul 25, 2015 · f20d45b · f20d45b
1 parent 10ed742
commit f20d45b
Show file tree

Hide file tree

Showing 6 changed files with 48 additions and 17 deletions.
diff --git a/src/main/java/org/redisson/RedissonScript.java b/src/main/java/org/redisson/RedissonScript.java
@@ -15,6 +15,7 @@
  */
 package org.redisson;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -140,6 +141,32 @@ public Future<Void> scriptKillAsync(String key) {
         return commandExecutor.writeAsync(key, RedisCommands.SCRIPT_KILL);
     }
 
+    @Override
+    public List<Boolean> scriptExists(String ... shaDigests) {
+        return commandExecutor.get(scriptExistsAsync(shaDigests));
+    }
+
+    @Override
+    public Future<List<Boolean>> scriptExistsAsync(final String ... shaDigests) {
+         return commandExecutor.writeAllAsync(RedisCommands.SCRIPT_EXISTS, new SlotCallback<List<Boolean>, List<Boolean>>() {
+            volatile List<Boolean> result = new ArrayList<Boolean>(shaDigests.length);
+            @Override
+            public synchronized void onSlotResult(List<Boolean> result) {
+                for (int i = 0; i < result.size(); i++) {
+                    if (this.result.size() == i) {
+                        this.result.add(false);
+                    }
+                    this.result.set(i, this.result.get(i) | result.get(i));
+                }
+            }
+
+            @Override
+            public List<Boolean> onFinish() {
+                return new ArrayList<Boolean>(result);
+            }
+        }, (Object[])shaDigests);
+    }
+
     public List<Boolean> scriptExists(String key, String ... shaDigests) {
         return commandExecutor.get(scriptExistsAsync(key, shaDigests));
     }

diff --git a/src/main/java/org/redisson/client/protocol/RedisCommands.java b/src/main/java/org/redisson/client/protocol/RedisCommands.java
@@ -48,14 +48,14 @@ public interface RedisCommands {
     RedisStrictCommand<Void> UNWATCH = new RedisStrictCommand<Void>("UNWATCH", new VoidReplayConvertor());
     RedisStrictCommand<Void> WATCH = new RedisStrictCommand<Void>("WATCH", new VoidReplayConvertor());
     RedisStrictCommand<Void> MULTI = new RedisStrictCommand<Void>("MULTI", new VoidReplayConvertor());
-    RedisCommand<List<Object>> EXEC = new RedisCommand<List<Object>>("EXEC", new ObjectListReplayDecoder());
+    RedisCommand<List<Object>> EXEC = new RedisCommand<List<Object>>("EXEC", new ObjectListReplayDecoder<Object>());
 
     RedisCommand<Long> SREM = new RedisCommand<Long>("SREM", 2, ValueType.OBJECTS);
     RedisCommand<Boolean> SADD = new RedisCommand<Boolean>("SADD", new BooleanAmountReplayConvertor(), 2, ValueType.OBJECTS);
     RedisCommand<Boolean> SADD_SINGLE = new RedisCommand<Boolean>("SADD", new BooleanReplayConvertor(), 2);
     RedisCommand<Boolean> SREM_SINGLE = new RedisCommand<Boolean>("SREM", new BooleanReplayConvertor(), 2);
-    RedisCommand<List<Object>> SMEMBERS = new RedisCommand<List<Object>>("SMEMBERS", new ObjectListReplayDecoder());
+    RedisCommand<List<Object>> SMEMBERS = new RedisCommand<List<Object>>("SMEMBERS", new ObjectListReplayDecoder<Object>());
-    RedisCommand<ListScanResult<Object>> SSCAN = new RedisCommand<ListScanResult<Object>>("SSCAN", new NestedMultiDecoder(new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.MAP);
+    RedisCommand<ListScanResult<Object>> SSCAN = new RedisCommand<ListScanResult<Object>>("SSCAN", new NestedMultiDecoder(new ObjectListReplayDecoder<Object>(), new ListScanResultReplayDecoder()), ValueType.MAP);
     RedisCommand<Boolean> SISMEMBER = new RedisCommand<Boolean>("SISMEMBER", new BooleanReplayConvertor(), 2);
     RedisStrictCommand<Integer> SCARD = new RedisStrictCommand<Integer>("SCARD", new IntegerReplayConvertor());
 
@@ -84,22 +84,22 @@ public interface RedisCommands {
 
     RedisCommand<Long> RPOP = new RedisCommand<Long>("RPOP");
     RedisCommand<Long> LPUSH = new RedisCommand<Long>("LPUSH");
-    RedisCommand<List<Object>> LRANGE = new RedisCommand<List<Object>>("LRANGE", new ObjectListReplayDecoder());
+    RedisCommand<List<Object>> LRANGE = new RedisCommand<List<Object>>("LRANGE", new ObjectListReplayDecoder<Object>());
     RedisCommand<Long> RPUSH = new RedisCommand<Long>("RPUSH", 2, ValueType.OBJECTS);
     RedisCommand<Boolean> RPUSH_BOOLEAN = new RedisCommand<Boolean>("RPUSH", new TrueReplayConvertor(), 2, ValueType.OBJECTS);
 
     RedisStrictCommand<String> SCRIPT_LOAD = new RedisStrictCommand<String>("SCRIPT", "LOAD", new StringDataDecoder());
     RedisStrictCommand<Boolean> SCRIPT_KILL = new RedisStrictCommand<Boolean>("SCRIPT", "KILL", new BooleanReplayConvertor());
     RedisStrictCommand<Boolean> SCRIPT_FLUSH = new RedisStrictCommand<Boolean>("SCRIPT", "FLUSH", new BooleanReplayConvertor());
-    RedisStrictCommand<List<Object>> SCRIPT_EXISTS = new RedisStrictCommand<List<Object>>("SCRIPT", "EXISTS", new ObjectListReplayDecoder(), new BooleanReplayConvertor());
+    RedisStrictCommand<List<Boolean>> SCRIPT_EXISTS = new RedisStrictCommand<List<Boolean>>("SCRIPT", "EXISTS", new ObjectListReplayDecoder<Boolean>(), new BooleanReplayConvertor());
 
     RedisStrictCommand<Boolean> EVAL_BOOLEAN = new RedisStrictCommand<Boolean>("EVAL", new BooleanReplayConvertor());
     RedisStrictCommand<String> EVAL_STRING = new RedisStrictCommand<String>("EVAL", new StringReplayDecoder());
     RedisStrictCommand<Long> EVAL_INTEGER = new RedisStrictCommand<Long>("EVAL");
-    RedisCommand<List<Object>> EVAL_LIST = new RedisCommand<List<Object>>("EVAL", new ObjectListReplayDecoder());
+    RedisCommand<List<Object>> EVAL_LIST = new RedisCommand<List<Object>>("EVAL", new ObjectListReplayDecoder<Object>());
     RedisCommand<Object> EVAL_OBJECT = new RedisCommand<Object>("EVAL");
     RedisCommand<Object> EVAL_MAP_VALUE = new RedisCommand<Object>("EVAL", ValueType.MAP_VALUE);
-    RedisCommand<List<Object>> EVAL_MAP_VALUE_LIST = new RedisCommand<List<Object>>("EVAL", new ObjectListReplayDecoder(), ValueType.MAP_VALUE);
+    RedisCommand<List<Object>> EVAL_MAP_VALUE_LIST = new RedisCommand<List<Object>>("EVAL", new ObjectListReplayDecoder<Object>(), ValueType.MAP_VALUE);
 
     RedisStrictCommand<Long> INCR = new RedisStrictCommand<Long>("INCR");
     RedisStrictCommand<Long> INCRBY = new RedisStrictCommand<Long>("INCRBY");
@@ -118,12 +118,12 @@ public interface RedisCommands {
     RedisStrictCommand<String> HINCRBYFLOAT = new RedisStrictCommand<String>("HINCRBYFLOAT");
     RedisCommand<MapScanResult<Object, Object>> HSCAN = new RedisCommand<MapScanResult<Object, Object>>("HSCAN", new NestedMultiDecoder(new ObjectMapReplayDecoder(), new MapScanResultReplayDecoder()), ValueType.MAP);
     RedisCommand<Map<Object, Object>> HGETALL = new RedisCommand<Map<Object, Object>>("HGETALL", new ObjectMapReplayDecoder(), ValueType.MAP);
-    RedisCommand<List<Object>> HVALS = new RedisCommand<List<Object>>("HVALS", new ObjectListReplayDecoder(), ValueType.MAP_VALUE);
+    RedisCommand<List<Object>> HVALS = new RedisCommand<List<Object>>("HVALS", new ObjectListReplayDecoder<Object>(), ValueType.MAP_VALUE);
     RedisCommand<Boolean> HEXISTS = new RedisCommand<Boolean>("HEXISTS", new BooleanReplayConvertor(), 2, ValueType.MAP_KEY);
     RedisStrictCommand<Integer> HLEN = new RedisStrictCommand<Integer>("HLEN", new IntegerReplayConvertor());
     RedisCommand<Set<Object>> HKEYS = new RedisCommand<Set<Object>>("HKEYS", new ObjectSetReplayDecoder(), ValueType.MAP_KEY);
     RedisCommand<String> HMSET = new RedisCommand<String>("HMSET", new StringReplayDecoder(), 1, ValueType.MAP);
-    RedisCommand<List<Object>> HMGET = new RedisCommand<List<Object>>("HMGET", new ObjectListReplayDecoder(), 2, ValueType.MAP_KEY, ValueType.MAP_VALUE);
+    RedisCommand<List<Object>> HMGET = new RedisCommand<List<Object>>("HMGET", new ObjectListReplayDecoder<Object>(), 2, ValueType.MAP_KEY, ValueType.MAP_VALUE);
     RedisCommand<Object> HGET = new RedisCommand<Object>("HGET", 2, ValueType.MAP_KEY, ValueType.MAP_VALUE);
     RedisCommand<Long> HDEL = new RedisStrictCommand<Long>("HDEL", 2, ValueType.MAP_KEY);
 

diff --git a/src/main/java/org/redisson/client/protocol/decoder/ObjectListReplayDecoder.java b/src/main/java/org/redisson/client/protocol/decoder/ObjectListReplayDecoder.java
@@ -21,16 +21,16 @@
 
 import io.netty.buffer.ByteBuf;
 
-public class ObjectListReplayDecoder implements MultiDecoder<List<Object>> {
+public class ObjectListReplayDecoder<T> implements MultiDecoder<List<T>> {
 
     @Override
     public Object decode(ByteBuf buf, State state) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public List<Object> decode(List<Object> parts, State state) {
+    public List<T> decode(List<Object> parts, State state) {
-        return parts;
+        return (List<T>) parts;
     }
 
     @Override

diff --git a/src/main/java/org/redisson/core/RScript.java b/src/main/java/org/redisson/core/RScript.java
@@ -55,6 +55,8 @@ public RedisCommand<?> getCommand() {
 
     String scriptLoad(String luaScript);
 
+    List<Boolean> scriptExists(String ... shaDigests);
+
     void scriptKill();
 
     void scriptFlush();

diff --git a/src/main/java/org/redisson/core/RScriptAsync.java b/src/main/java/org/redisson/core/RScriptAsync.java
@@ -32,6 +32,8 @@ public interface RScriptAsync {
 
     Future<String> scriptLoadAsync(String luaScript);
 
+    Future<List<Boolean>> scriptExistsAsync(String ... shaDigests);
+
     Future<Void> scriptKillAsync();
 
 }
diff --git a/src/test/java/org/redisson/RedissonScriptTest.java b/src/test/java/org/redisson/RedissonScriptTest.java
@@ -32,16 +32,16 @@ public void testEvalAsync() {
     @Test
     public void testScriptExists() {
         RScript s = redisson.getScript();
-        String r = s.scriptLoad(null, "return redis.call('get', 'foo')");
+        String r = s.scriptLoad("return redis.call('get', 'foo')");
         Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", r);
 
-        List<Boolean> r1 = s.scriptExists(null, r);
+        List<Boolean> r1 = s.scriptExists(r);
         Assert.assertEquals(1, r1.size());
         Assert.assertTrue(r1.get(0));
 
         s.scriptFlush();
 
-        List<Boolean> r2 = s.scriptExists(null, r);
+        List<Boolean> r2 = s.scriptExists(r);
         Assert.assertEquals(1, r2.size());
         Assert.assertFalse(r2.get(0));
     }
@@ -83,7 +83,7 @@ public void testScriptLoadAsync() {
     @Test
     public void testEvalSha() {
         RScript s = redisson.getScript();
-        String res = s.scriptLoad(null, "return redis.call('get', 'foo')");
+        String res = s.scriptLoad("return redis.call('get', 'foo')");
         Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", res);
 
         redisson.getBucket("foo").set("bar");
@@ -94,7 +94,7 @@ public void testEvalSha() {
     @Test
     public void testEvalshaAsync() {
         RScript s = redisson.getScript();
-        String res = s.scriptLoad(null, "return redis.call('get', 'foo')");
+        String res = s.scriptLoad("return redis.call('get', 'foo')");
         Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", res);
 
         redisson.getBucket("foo").set("bar");