From a16dca92229ec3a7825d9ba33c7b58cb4daa2d70 Mon Sep 17 00:00:00 2001 From: Nikita Date: Thu, 2 Apr 2015 15:39:32 +0300 Subject: [PATCH] All script commands support. #73 --- .../redis/RedisAsyncConnection.java | 9 +- .../java/org/redisson/RedissonScript.java | 87 ++++++++++++++++++- src/main/java/org/redisson/core/RScript.java | 24 +++++ .../java/org/redisson/RedissonScriptTest.java | 74 +++++++++++++++- 4 files changed, 191 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/lambdaworks/redis/RedisAsyncConnection.java b/src/main/java/com/lambdaworks/redis/RedisAsyncConnection.java index d26d052e6..e7b7a53fc 100644 --- a/src/main/java/com/lambdaworks/redis/RedisAsyncConnection.java +++ b/src/main/java/com/lambdaworks/redis/RedisAsyncConnection.java @@ -312,6 +312,13 @@ public class RedisAsyncConnection extends ChannelInboundHandlerAdapter { return dispatch(EVAL, output, args); } + public Future evalsha(String digest, ScriptOutputType type, List keys, V... values) { + CommandArgs args = new CommandArgs(codec); + args.add(digest).add(keys.size()).addKeys(keys).addValues(values); + CommandOutput output = newScriptOutput(codec, type); + return dispatch(EVALSHA, output, args); + } + public Future evalsha(String digest, ScriptOutputType type, K[] keys, V... values) { CommandArgs args = new CommandArgs(codec); args.add(digest).add(keys.length).addKeys(keys).addValues(values); @@ -663,7 +670,7 @@ public class RedisAsyncConnection extends ChannelInboundHandlerAdapter { } public Future scriptLoad(V script) { - CommandArgs args = new CommandArgs(codec).add(LOAD).addValue(script); + CommandArgs args = new CommandArgs(codec).add(LOAD).add(script.toString()); return dispatch(SCRIPT, new StatusOutput(codec), args); } diff --git a/src/main/java/org/redisson/RedissonScript.java b/src/main/java/org/redisson/RedissonScript.java index 9bce128a5..24ae83580 100644 --- a/src/main/java/org/redisson/RedissonScript.java +++ b/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 eval(final String luaScript, final ReturnType returnType, final List keys, final Object... values) { + public String scriptLoad(String luaScript) { + return connectionManager.get(scriptLoadAsync(luaScript)); + } + + @Override + public Future scriptLoadAsync(final String luaScript) { + return connectionManager.writeAsync(new ResultOperation() { + @Override + protected Future execute(RedisAsyncConnection async) { + return async.scriptLoad(luaScript); + } + }); + } + + @Override + public R eval(String luaScript, ReturnType returnType) { + return eval(luaScript, returnType, Collections.emptyList()); + } + + @Override + public R eval(String luaScript, ReturnType returnType, List keys, Object... values) { return (R) connectionManager.get(evalAsync(luaScript, returnType, keys, values)); } @@ -48,6 +69,70 @@ public class RedissonScript implements RScript { } }); } + + @Override + public R evalSha(String shaDigest, ReturnType returnType) { + return evalSha(shaDigest, returnType, Collections.emptyList()); + } + + @Override + public R evalSha(String shaDigest, ReturnType returnType, List keys, Object... values) { + return (R) connectionManager.get(evalShaAsync(shaDigest, returnType, keys, values)); + } + + @Override + public Future evalShaAsync(final String shaDigest, final ReturnType returnType, final List keys, final Object... values) { + return connectionManager.writeAsync(new ResultOperation() { + @Override + protected Future execute(RedisAsyncConnection async) { + return async.evalsha(shaDigest, ScriptOutputType.valueOf(returnType.toString()), keys, values); + } + }); + } + + @Override + public String scriptKill() { + return connectionManager.get(scriptKillAsync()); + } + + @Override + public Future scriptKillAsync() { + return connectionManager.writeAsync(new ResultOperation() { + @Override + protected Future execute(RedisAsyncConnection async) { + return async.scriptKill(); + } + }); + } + + @Override + public List scriptExists(String ... shaDigests) { + return connectionManager.get(scriptExistsAsync(shaDigests)); + } + + @Override + public Future> scriptExistsAsync(final String ... shaDigests) { + return connectionManager.writeAsync(new ResultOperation, Object>() { + @Override + protected Future> execute(RedisAsyncConnection async) { + return async.scriptExists(shaDigests); + } + }); + } + @Override + public String scriptFlush() { + return connectionManager.get(scriptFlushAsync()); + } + + @Override + public Future scriptFlushAsync() { + return connectionManager.writeAsync(new ResultOperation() { + @Override + protected Future execute(RedisAsyncConnection async) { + return async.scriptFlush(); + } + }); + } } diff --git a/src/main/java/org/redisson/core/RScript.java b/src/main/java/org/redisson/core/RScript.java index e56a9a4bb..e2a27f220 100644 --- a/src/main/java/org/redisson/core/RScript.java +++ b/src/main/java/org/redisson/core/RScript.java @@ -23,8 +23,32 @@ public interface RScript { enum ReturnType {BOOLEAN, INTEGER, MULTI, STATUS, VALUE}; + List scriptExists(String ... shaDigests); + + Future> scriptExistsAsync(String ... shaDigests); + + String scriptFlush(); + + Future scriptFlushAsync(); + + String scriptKill(); + + Future scriptKillAsync(); + + String scriptLoad(String luaScript); + + Future scriptLoadAsync(String luaScript); + + R evalSha(String shaDigest, ReturnType returnType); + + R evalSha(String shaDigest, ReturnType returnType, List keys, Object... values); + + Future evalShaAsync(String shaDigest, ReturnType returnType, List keys, Object... values); + Future evalAsync(String luaScript, ReturnType returnType, List keys, Object... values); + R eval(String luaScript, ReturnType returnType); + R eval(String luaScript, ReturnType returnType, List keys, Object... values); } diff --git a/src/test/java/org/redisson/RedissonScriptTest.java b/src/test/java/org/redisson/RedissonScriptTest.java index 7f13ab1de..53a169a62 100644 --- a/src/test/java/org/redisson/RedissonScriptTest.java +++ b/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> res = script.evalAsync("return {1,2,3.3333,'foo',nil,'bar'}", RScript.ReturnType.MULTI, Collections.emptyList()); MatcherAssert.assertThat(res.awaitUninterruptibly().getNow(), Matchers.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 r1 = s.scriptExists(r); + Assert.assertEquals(1, r1.size()); + Assert.assertTrue(r1.get(0)); + + s.scriptFlush(); + + List 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 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 r1 = redisson.getScript().evalShaAsync("282297a0228f48cd3fc6a55de6316f31422f5d17", RScript.ReturnType.VALUE, Collections.emptyList()); + Assert.assertEquals("bar", r1.awaitUninterruptibly().getNow()); + } + }