All script commands support. #73

src/main/java/com/lambdaworks/redis/RedisAsyncConnection.java

@@ -312,6 +312,13 @@ public class RedisAsyncConnection<K, V> extends ChannelInboundHandlerAdapter {
         return dispatch(EVAL, output, args);
     }
 
+    public <T> Future<T> evalsha(String digest, ScriptOutputType type, List<K> keys, V... values) {
+        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        args.add(digest).add(keys.size()).addKeys(keys).addValues(values);
+        CommandOutput<K, V, T> output = newScriptOutput(codec, type);
+        return dispatch(EVALSHA, output, args);
+    }
+    
     public <T> Future<T> evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
         CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
         args.add(digest).add(keys.length).addKeys(keys).addValues(values);
@@ -663,7 +670,7 @@ public class RedisAsyncConnection<K, V> extends ChannelInboundHandlerAdapter {
     }
 
     public Future<String> scriptLoad(V script) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(LOAD).addValue(script);
+        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(LOAD).add(script.toString());
         return dispatch(SCRIPT, new StatusOutput<K, V>(codec), args);
     }
 

src/main/java/org/redisson/RedissonScript.java

@@ -17,6 +17,7 @@ package org.redisson;
 
 import io.netty.util.concurrent.Future;
 
+import java.util.Collections;
 import java.util.List;
 
 import org.redisson.async.ResultOperation;
@@ -35,7 +36,27 @@ public class RedissonScript implements RScript {
     }
 
     @Override
-    public <R> R eval(final String luaScript, final ReturnType returnType, final List<Object> keys, final Object... values) {
+    public String scriptLoad(String luaScript) {
+        return connectionManager.get(scriptLoadAsync(luaScript));
+    }
+
+    @Override
+    public Future<String> scriptLoadAsync(final String luaScript) {
+        return connectionManager.writeAsync(new ResultOperation<String, Object>() {
+            @Override
+            protected Future<String> execute(RedisAsyncConnection<Object, Object> async) {
+                return async.scriptLoad(luaScript);
+            }
+        });
+    }
+    
+    @Override
+    public <R> R eval(String luaScript, ReturnType returnType) {
+        return eval(luaScript, returnType, Collections.emptyList());
+    }
+    
+    @Override
+    public <R> R eval(String luaScript, ReturnType returnType, List<Object> keys, Object... values) {
         return (R) connectionManager.get(evalAsync(luaScript, returnType, keys, values));
     }
 
@@ -48,6 +69,70 @@ public class RedissonScript implements RScript {
             }
         });
     }
+
+    @Override
+    public <R> R evalSha(String shaDigest, ReturnType returnType) {
+        return evalSha(shaDigest, returnType, Collections.emptyList());
+    }
+    
+    @Override
+    public <R> R evalSha(String shaDigest, ReturnType returnType, List<Object> keys, Object... values) {
+        return (R) connectionManager.get(evalShaAsync(shaDigest, returnType, keys, values));
+    }
+    
+    @Override
+    public <R> Future<R> evalShaAsync(final String shaDigest, final ReturnType returnType, final List<Object> keys, final Object... values) {
+        return connectionManager.writeAsync(new ResultOperation<R, Object>() {
+            @Override
+            protected Future<R> execute(RedisAsyncConnection<Object, Object> async) {
+                return async.evalsha(shaDigest, ScriptOutputType.valueOf(returnType.toString()), keys, values);
+            }
+        });
+    }
+
+    @Override
+    public String scriptKill() {
+        return connectionManager.get(scriptKillAsync());
+    }
+    
+    @Override
+    public Future<String> scriptKillAsync() {
+        return connectionManager.writeAsync(new ResultOperation<String, Object>() {
+            @Override
+            protected Future<String> execute(RedisAsyncConnection<Object, Object> async) {
+                return async.scriptKill();
+            }
+        });
+    }
+    
+    @Override
+    public List<Boolean> scriptExists(String ... shaDigests) {
+        return connectionManager.get(scriptExistsAsync(shaDigests));
+    }
+
+    @Override
+    public Future<List<Boolean>> scriptExistsAsync(final String ... shaDigests) {
+        return connectionManager.writeAsync(new ResultOperation<List<Boolean>, Object>() {
+            @Override
+            protected Future<List<Boolean>> execute(RedisAsyncConnection<Object, Object> async) {
+                return async.scriptExists(shaDigests);
+            }
+        });
+    }
     
+    @Override
+    public String scriptFlush() {
+        return connectionManager.get(scriptFlushAsync());
+    }
+    
+    @Override
+    public Future<String> scriptFlushAsync() {
+        return connectionManager.writeAsync(new ResultOperation<String, Object>() {
+            @Override
+            protected Future<String> execute(RedisAsyncConnection<Object, Object> async) {
+                return async.scriptFlush();
+            }
+        });
+    }
     
 }

src/main/java/org/redisson/core/RScript.java

@@ -23,8 +23,32 @@ public interface RScript {
     
     enum ReturnType {BOOLEAN, INTEGER, MULTI, STATUS, VALUE};
 
+    List<Boolean> scriptExists(String ... shaDigests);
+    
+    Future<List<Boolean>> scriptExistsAsync(String ... shaDigests);
+    
+    String scriptFlush();
+    
+    Future<String> scriptFlushAsync();
+    
+    String scriptKill();
+    
+    Future<String> scriptKillAsync();
+    
+    String scriptLoad(String luaScript);
+    
+    Future<String> scriptLoadAsync(String luaScript);
+    
+    <R> R evalSha(String shaDigest, ReturnType returnType);
+    
+    <R> R evalSha(String shaDigest, ReturnType returnType, List<Object> keys, Object... values);
+    
+    <R> Future<R> evalShaAsync(String shaDigest, ReturnType returnType, List<Object> keys, Object... values);
+    
     <R> Future<R> evalAsync(String luaScript, ReturnType returnType, List<Object> keys, Object... values);
     
+    <R> R eval(String luaScript, ReturnType returnType);
+    
     <R> R eval(String luaScript, ReturnType returnType, List<Object> keys, Object... values);
     
 }

src/test/java/org/redisson/RedissonScriptTest.java

@@ -4,13 +4,15 @@ import io.netty.util.concurrent.Future;
 
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
 
 import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
+import org.junit.Assert;
 import org.junit.Test;
 import org.redisson.core.RScript;
 
+import com.lambdaworks.redis.RedisException;
+
 public class RedissonScriptTest extends BaseTest {
 
     @Test
@@ -26,5 +28,75 @@ public class RedissonScriptTest extends BaseTest {
         Future<List<Object>> res = script.evalAsync("return {1,2,3.3333,'foo',nil,'bar'}", RScript.ReturnType.MULTI, Collections.emptyList());
         MatcherAssert.assertThat(res.awaitUninterruptibly().getNow(), Matchers.<Object>contains(1L, 2L, 3L, "foo"));
     }
+
+    @Test
+    public void testScriptExists() {
+        RScript s = redisson.getScript();
+        String r = s.scriptLoad("return redis.call('get', 'foo')");
+        Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", r);
+        
+        List<Boolean> r1 = s.scriptExists(r);
+        Assert.assertEquals(1, r1.size());
+        Assert.assertTrue(r1.get(0));
+
+        s.scriptFlush();
+        
+        List<Boolean> r2 = s.scriptExists(r);
+        Assert.assertEquals(1, r2.size());
+        Assert.assertFalse(r2.get(0));
+    }
+    
+    @Test
+    public void testScriptFlush() {
+        redisson.getBucket("foo").set("bar");
+        String r = redisson.getScript().scriptLoad("return redis.call('get', 'foo')");
+        Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", r);
+        String r1 = redisson.getScript().evalSha("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        Assert.assertEquals("bar", r1);
+        String r2 = redisson.getScript().scriptFlush();
+        Assert.assertEquals("OK", r2);
+        try {
+            redisson.getScript().evalSha("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        } catch (Exception e) {
+            Assert.assertEquals(RedisException.class, e.getClass());
+        }
+    }
+    
+    @Test
+    public void testScriptLoad() {
+        redisson.getBucket("foo").set("bar");
+        String r = redisson.getScript().scriptLoad("return redis.call('get', 'foo')");
+        Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", r);
+        String r1 = redisson.getScript().evalSha("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        Assert.assertEquals("bar", r1);
+    }
+    
+    @Test
+    public void testScriptLoadAsync() {
+        redisson.getBucket("foo").set("bar");
+        Future<String> r = redisson.getScript().scriptLoadAsync("return redis.call('get', 'foo')");
+        Assert.assertEquals("282297a0228f48cd3fc6a55de6316f31422f5d17", r.awaitUninterruptibly().getNow());
+        String r1 = redisson.getScript().evalSha("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        Assert.assertEquals("bar", r1);
+    }
+    
+    @Test
+    public void testEvalSha() {
+        redisson.getBucket("foo").set("bar");
+        String r = redisson.getScript().eval("return redis.call('get', 'foo')", RScript.ReturnType.VALUE);
+        Assert.assertEquals("bar", r);
+        String r1 = redisson.getScript().evalSha("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        Assert.assertEquals("bar", r1);
+    }
+    
+    @Test
+    public void testEvalshaAsync() {
+        redisson.getBucket("foo").set("bar");
+        String r = redisson.getScript().eval("return redis.call('get', 'foo')", RScript.ReturnType.VALUE);
+        Assert.assertEquals("bar", r);
+        Future<Object> r1 = redisson.getScript().evalShaAsync("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList());
+        Assert.assertEquals("bar", r1.awaitUninterruptibly().getNow());
+    }
+
     
 }