jruby-memcached-thoughtworks 0.6.0

data/src/main/java/com/openfeint/memcached/MemcachedService.java

@@ -0,0 +1,35 @@
+package com.openfeint.memcached;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class MemcachedService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby ruby) throws IOException {
+        RubyClass memcached = ruby.defineClass("Memcached", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass klazz) {
+                return new Memcached(ruby, klazz);
+            }
+        });
+        memcached.defineAnnotatedMethods(Memcached.class);
+
+        RubyClass rails = memcached.defineClassUnder("Rails", memcached, new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass klazz) {
+                return new Rails(ruby, klazz);
+            }
+        });
+        rails.defineAnnotatedMethods(Rails.class);
+
+        RubyClass runtimeError = ruby.getRuntimeError();
+        RubyClass memcachedError = memcached.defineClassUnder("Error", runtimeError, runtimeError.getAllocator());
+        memcached.defineClassUnder("NotFound", memcachedError, memcachedError.getAllocator());
+        memcached.defineClassUnder("NotStored", memcachedError, memcachedError.getAllocator());
+        memcached.defineClassUnder("NotSupport", memcachedError, memcachedError.getAllocator());
+        memcached.defineClassUnder("ATimeoutOccurred", memcachedError, memcachedError.getAllocator());
+        return true;
+    }
+}

data/src/main/java/com/openfeint/memcached/Rails.java

@@ -0,0 +1,237 @@
+package com.openfeint.memcached;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+
+@JRubyClass(name = "Memcached::Rails", parent = "Memcached")
+public class Rails extends Memcached {
+    private boolean stringReturnTypes;
+
+    public Rails(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+
+        stringReturnTypes = false;
+    }
+
+    @JRubyMethod(name = "initialize", rest = true)
+    public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+
+        List<String> servers = new ArrayList<String>();
+        for (IRubyObject arg : args) {
+            if (arg instanceof RubyString) {
+                servers.add(arg.toString());
+            } else if (arg instanceof RubyArray) {
+                servers.addAll((List<String>) arg.convertToArray());
+            }
+        }
+
+        Map<String, String> options = new HashMap<String, String>();
+        if (args[args.length - 1] instanceof RubyHash) {
+            RubyHash arguments = args[args.length - 1].convertToHash();
+            for (Object key : arguments.keySet()) {
+                if (!"servers".equals(key.toString())) {
+                    options.put(key.toString(), arguments.get(key).toString());
+                }
+            }
+            if (servers.isEmpty()) {
+                IRubyObject serverNames = (IRubyObject) arguments.get(ruby.newSymbol("servers"));
+                servers.addAll((List<String>) serverNames.convertToArray());
+            }
+        }
+        if (options.containsKey("namespace")) {
+            options.put("prefix_key", options.get("namespace"));
+        }
+        if (options.containsKey("namespace_separator")) {
+            options.put("prefix_delimiter", options.get("namespace_separator"));
+        }
+        if (options.containsKey("string_return_types")) {
+            stringReturnTypes = true;
+        }
+        return super.init(context, servers, options);
+    }
+
+    @JRubyMethod(name = "active?")
+    public IRubyObject active_p(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
+        if (((RubyArray) super.servers(context)).isEmpty()) {
+            return ruby.getFalse();
+        }
+        return ruby.getTrue();
+    }
+
+    @JRubyMethod(name = { "get", "[]" }, required = 1, optional = 1)
+    public IRubyObject get(ThreadContext context, IRubyObject[] args) {
+        IRubyObject key = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        try {
+            return super.get(context, new IRubyObject[] { key, notRaw });
+        } catch (RaiseException e) {
+            return context.nil;
+        }
+    }
+
+    @JRubyMethod(name = "read", required = 1, optional = 1)
+    public IRubyObject read(ThreadContext context, IRubyObject[] args) {
+        IRubyObject key = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        return get(context, new IRubyObject[] { key, notRaw });
+    }
+
+    @JRubyMethod(name = "exist?", required = 1, optional = 1)
+    public IRubyObject exist_p(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        try {
+            super.get(context, args);
+            return ruby.getTrue();
+        } catch (RaiseException e) {
+            return ruby.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = "get_multi", required = 1, optional = 1)
+    public IRubyObject getMulti(ThreadContext context, IRubyObject[] args) {
+        IRubyObject keys = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        return super.get(context, new IRubyObject[] { keys, notRaw });
+    }
+
+    @JRubyMethod(name = { "set", "[]=" }, required = 2, optional = 2)
+    public IRubyObject set(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        IRubyObject value = args[1];
+        RubyFixnum ttl = getTTL(context, args, 2);
+        RubyBoolean notRaw = notRaw(context, args, 3);
+        try {
+            super.set(context, new IRubyObject[] { key, value, ttl, notRaw });
+            return ruby.getTrue();
+        } catch (RaiseException e) {
+            return ruby.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = "write", required = 2, optional = 1)
+    public IRubyObject write(ThreadContext context, IRubyObject[] args) {
+        IRubyObject key = args[0];
+        IRubyObject value = args[1];
+        RubyFixnum ttl = getTTL(context, args, 2);
+        RubyBoolean notRaw = notRaw(context, args, 2);
+        return set(context, new IRubyObject[] { key, value, ttl, notRaw });
+    }
+
+    @JRubyMethod(name = "fetch", required = 1, optional = 1)
+    public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        RubyHash options;
+        if (args.length > 1) {
+            options = (RubyHash) args[1];
+        } else {
+            options = new RubyHash(ruby);
+        }
+        IRubyObject value = read(context, args);
+        if (value.isNil()) {
+            value = block.call(context);
+            write(context, new IRubyObject[] { key, value, options });
+        }
+        return value;
+    }
+
+    @JRubyMethod(name = "add", required = 2, optional = 2)
+    public IRubyObject add(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        if (args.length > 3) {
+            if (ruby.getTrue() == args[3]) {
+                args[3] = ruby.getFalse();
+            } else {
+                args[3] = ruby.getTrue();
+            }
+        }
+        try {
+            super.add(context, args);
+            if (stringReturnTypes) {
+                return ruby.newString("STORED\r\n");
+            } else {
+                return ruby.getTrue();
+            }
+        } catch (RaiseException e) {
+            if (stringReturnTypes) {
+                return ruby.newString("NOT STORED\r\n");
+            } else {
+                return ruby.getFalse();
+            }
+        }
+    }
+
+    @JRubyMethod(name = "delete", required = 1, optional = 1)
+    public IRubyObject delete(ThreadContext context, IRubyObject[] args) {
+        try {
+            super.delete(context, args[0]);
+        } catch(RaiseException e) { }
+
+        return context.nil;
+    }
+
+    @JRubyMethod(name = { "flush", "flush_all", "clear" })
+    public IRubyObject flush(ThreadContext context) {
+        return super.flush(context);
+    }
+
+    @JRubyMethod(name = "read_multi", rest = true)
+    public IRubyObject readMulti(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        if (args.length == 0) {
+            return new RubyHash(ruby);
+        } else {
+            return getMulti(context, args);
+        }
+    }
+
+    private RubyFixnum getTTL(ThreadContext context, IRubyObject[] args, int index) {
+        Ruby ruby = context.getRuntime();
+        if (args.length > index) {
+            if (args[index] instanceof RubyFixnum) {
+                return (RubyFixnum) args[index];
+            } else if (args[index] instanceof RubyHash) {
+                RubyHash options = (RubyHash) args[index];
+                if (options.containsKey(ruby.newSymbol("ttl"))) {
+                    Long ttl = (Long) options.get(ruby.newSymbol("ttl"));
+                    return ruby.newFixnum(ttl);
+                } else if (options.containsKey(ruby.newSymbol("expires_in"))) {
+                    Long expiresIn = (Long) options.get(ruby.newSymbol("expires_in"));
+                    return ruby.newFixnum(expiresIn);
+                }
+            }
+        }
+        return ruby.newFixnum(super.getDefaultTTL());
+    }
+
+    private RubyBoolean notRaw(ThreadContext context, IRubyObject[] args, int index) {
+        Ruby ruby = context.getRuntime();
+        RubyBoolean notRaw = ruby.getTrue();
+        if (args.length > index) {
+            if ((args[index] instanceof RubyBoolean && ruby.getTrue() == args[index]) ||
+                (args[index] instanceof RubyHash && ruby.getTrue() == ((RubyHash) args[index]).get(ruby.newSymbol("raw")))) {
+                notRaw = ruby.getFalse();
+            }
+        }
+        return notRaw;
+    }
+}

data/src/main/java/com/openfeint/memcached/error/ATimeoutOccurred.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::ATimeoutOccurred", parent="Memcached::Error")
+public class ATimeoutOccurred extends Error {
+}

data/src/main/java/com/openfeint/memcached/error/Error.java

@@ -0,0 +1,31 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.anno.JRubyClass;
+import org.jruby.exceptions.RaiseException;
+
+@JRubyClass(name = "Memcached::Error", parent = "RuntimeError")
+public class Error {
+    public static RaiseException newNotFound(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotFound", message);
+    }
+
+    public static RaiseException newNotStored(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotStored", message);
+    }
+
+    public static RaiseException newNotSupport(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotSupport", message);
+    }
+
+    public static RaiseException newATimeoutOccurred(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "ATimeoutOccurred", message);
+    }
+
+    private static RaiseException newMemcachedError(Ruby ruby, String klass, String message) {
+        RubyClass errorClass = ruby.getModule("Memcached").getClass(klass);
+        return new RaiseException(RubyException.newException(ruby, errorClass, message), true);
+    }
+}

data/src/main/java/com/openfeint/memcached/error/NotFound.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotFound", parent="Memcached::Error")
+public class NotFound extends Error {
+}

data/src/main/java/com/openfeint/memcached/error/NotStored.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotStored", parent="Memcached::Error")
+public class NotStored extends Error {
+}

data/src/main/java/com/openfeint/memcached/error/NotSupport.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotSupport", parent="Memcached::Error")
+public class NotSupport extends Error {
+}

data/src/main/java/com/openfeint/memcached/transcoder/MarshalTranscoder.java

@@ -0,0 +1,91 @@
+package com.openfeint.memcached.transcoder;
+
+import net.spy.memcached.CachedData;
+import net.spy.memcached.transcoders.Transcoder;
+import org.jruby.Ruby;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.marshal.MarshalStream;
+import org.jruby.runtime.marshal.UnmarshalStream;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ *
+ * MarshalTranscoder does marshaling and unmarshaling.
+ *
+ */
+public class MarshalTranscoder implements Transcoder {
+    protected Ruby ruby;
+    private int flags;
+
+    public MarshalTranscoder(Ruby ruby) {
+        this(ruby, 0);
+    }
+
+    public MarshalTranscoder(Ruby ruby, int flags) {
+        this.ruby = ruby;
+        this.flags = flags;
+    }
+
+    public boolean asyncDecode(CachedData d) {
+        return false;
+    }
+
+    public CachedData encode(Object o) {
+        if (o instanceof IRubyObject) {
+            try {
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                MarshalStream marshal = new MarshalStream(ruby, baos, Integer.MAX_VALUE);
+                marshal.dumpObject((IRubyObject) o);
+                byte[] bytes = baos.toByteArray();
+                return new CachedData(getFlags(), bytes, bytes.length);
+            } catch (IOException e) {
+                throw ruby.newIOErrorFromException(e);
+            }
+        } else {
+            return encodeNumber(o);
+        }
+    }
+
+    public Object decode(CachedData d) {
+        try {
+            return new UnmarshalStream(ruby, new ByteArrayInputStream(d.getData()), null, false, false).unmarshalObject();
+        } catch (RaiseException e) {
+            return decodeNumber(d, e);
+        } catch (IOException e) {
+            return decodeNumber(d, e);
+        }
+    }
+
+    public int getMaxSize() {
+        return CachedData.MAX_SIZE;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+
+    protected CachedData encodeNumber(Object o) {
+        byte[] bytes = o.toString().getBytes();
+        return new CachedData(getFlags(), bytes, bytes.length);
+    }
+
+    protected Long decodeNumber(CachedData d, RaiseException originalException) {
+        try {
+            return Long.valueOf(new String(d.getData()).trim());
+        } catch (NumberFormatException e) {
+            throw ruby.newRuntimeError(originalException.getLocalizedMessage());
+        }
+    }
+
+    protected Long decodeNumber(CachedData d, IOException originalException) {
+        try {
+            return Long.valueOf(new String(d.getData()).trim());
+        } catch (NumberFormatException e) {
+            throw ruby.newIOErrorFromException(originalException);
+        }
+    }
+}

data/src/main/java/com/openfeint/memcached/transcoder/MarshalZlibTranscoder.java

@@ -0,0 +1,103 @@
+package com.openfeint.memcached.transcoder;
+
+import com.jcraft.jzlib.JZlib;
+import com.jcraft.jzlib.ZInputStream;
+import com.jcraft.jzlib.ZOutputStream;
+import net.spy.memcached.CachedData;
+import org.jruby.Ruby;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.marshal.MarshalStream;
+import org.jruby.runtime.marshal.UnmarshalStream;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ *
+ * MarshalZlibTranscoder do marshaling/unmarshaling and compressing/decompressing with zlib.
+ *
+ */
+public class MarshalZlibTranscoder extends MarshalTranscoder {
+    static final int COMPRESS_FLAG = 1;
+
+    public MarshalZlibTranscoder(Ruby ruby) {
+        super(ruby, COMPRESS_FLAG);
+    }
+
+    public MarshalZlibTranscoder(Ruby ruby, int flags) {
+        super(ruby, flags);
+    }
+
+    public CachedData encode(Object o) {
+        if (o instanceof IRubyObject) {
+            ZOutputStream zout = null;
+            try {
+                ByteArrayOutputStream out1 = new ByteArrayOutputStream();
+                MarshalStream marshal = new MarshalStream(ruby, out1, Integer.MAX_VALUE);
+                marshal.dumpObject((IRubyObject) o);
+
+                byte[] bytes;
+                if (getFlags() == COMPRESS_FLAG) {
+                    ByteArrayOutputStream out2 = new ByteArrayOutputStream();
+                    zout = new ZOutputStream(out2, JZlib.Z_DEFAULT_COMPRESSION);
+                    zout.write(out1.toByteArray());
+                    zout.flush();
+                    zout.end();
+                    bytes = out2.toByteArray();
+                } else {
+                    bytes = out1.toByteArray();
+                }
+
+                return new CachedData(super.getFlags(), bytes, bytes.length);
+            } catch (IOException e) {
+                throw ruby.newIOErrorFromException(e);
+            } finally {
+                if (zout != null) {
+                    try {
+                        zout.close();
+                    } catch (IOException e) {}
+                    zout = null;
+                }
+            }
+        } else {
+            return super.encodeNumber(o);
+        }
+    }
+
+    public Object decode(CachedData d) {
+        ZInputStream zin = null;
+        try {
+            byte[] bytes;
+            if (d.getFlags() == COMPRESS_FLAG) {
+                ByteArrayInputStream in = new ByteArrayInputStream(d.getData());
+                zin = new ZInputStream(in);
+
+                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+                int nRead;
+                byte[] data = new byte[1024];
+                while ((nRead = zin.read(data, 0, data.length)) != -1) {
+                    buffer.write(data, 0, nRead);
+                }
+                buffer.flush();
+                bytes = buffer.toByteArray();
+            } else {
+                bytes = d.getData();
+            }
+
+            return new UnmarshalStream(ruby, new ByteArrayInputStream(bytes), null, false, false).unmarshalObject();
+        } catch (RaiseException e) {
+            return super.decodeNumber(d, e);
+        } catch (IOException e) {
+            return super.decodeNumber(d, e);
+        } finally {
+            if (zin != null) {
+                try {
+                    zin.close();
+                } catch (IOException e) {}
+                zin = null;
+            }
+        }
+    }
+}