jruby-memcached 0.2.0 → 0.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jruby-memcached (0.2.0)
+    jruby-memcached (0.3.0)
 
 GEM
   remote: http://rubygems.org/

data/benchmark.rb

@@ -2,15 +2,17 @@ require 'benchmark'
 
 JRUBY = defined?(JRUBY_VERSION)
 
+require 'rubygems'
 if JRUBY
   require 'lib/memcached'
+  require 'jruby-spymemcached'
 else
   require 'memcached'
 end
-require 'rubygems'
 require 'dalli'
 
 memcached = Memcached.new(['localhost:11211'])
+spymemcached = Spymemcached.new(['localhost:11211']) if JRUBY
 dalli = Dalli::Client.new(['localhost:11211'])
 
 3.to_i.times {
@@ -22,6 +24,12 @@ dalli = Dalli::Client.new(['localhost:11211'])
       bm.report("jruby-memcached get") {
         100_000.times { memcached.get('foo') }
       }
+      bm.report("jruby-spymemcached set") {
+        100_000.times { spymemcached.set('foo', 'bar') }
+      }
+      bm.report("jruby-spymemcached get") {
+        100_000.times { spymemcached.get('foo') }
+      }
     else
       bm.report("memcached set") {
         100_000.times { memcached.set('foo', 'bar') }
@@ -44,29 +52,46 @@ dalli = Dalli::Client.new(['localhost:11211'])
   }
 }
 
-memcached.close
+if JRUBY
+  memcached.shutdown
+  spymemcached.shutdown
+end
 dalli.close
 
-
-# MBP 2.8G i7
+# I run benchmark for each client 3 times, but only list the last result for each.
+#
+# MBP 2.8G i7    jruby-memcached 0.3.0
 #
 # ruby-1.9.3-p194
 # ruby benchmark.rb
 #                                      user     system      total        real
-# memcached set                    1.110000   1.010000   2.120000 (  4.578121)
-# memcached get                    0.940000   0.960000   1.900000 (  4.013941)
-#                                      user     system      total        real
-# memcached set                    1.100000   1.010000   2.110000 (  4.557462)
-# memcached get                    0.930000   0.950000   1.880000 (  3.995192)
-#                                      user     system      total        real
 # memcached set                    1.110000   1.020000   2.130000 (  4.592509)
 # memcached get                    0.970000   1.000000   1.970000 (  4.172170)
 #                                      user     system      total        real
-# dalli set                        8.330000   1.570000   9.900000 ( 10.062159)
-# dalli get                        8.240000   1.630000   9.870000 (  9.987921)
+# dalli set                        8.360000   1.650000  10.010000 ( 10.193101)
+# dalli get                        8.040000   1.670000   9.710000 (  9.828392)
+#
+# jruby-1.6.7.2
+# jruby --server -Ilib -S benchmark.rb
+#                                     user     system      total        real
+# jruby-memcached set             5.842000   0.000000   5.842000 (  5.842000)
+# jruby-memcached get             5.561000   0.000000   5.561000 (  5.561000)
+#                                     user     system      total        real
+# jruby-spymemcached set          5.919000   0.000000   5.919000 (  5.919000)
+# jruby-spymemcached get          5.615000   0.000000   5.615000 (  5.615000)
+#                                     user     system      total        real
+# dalli set                      10.132000   0.000000  10.132000 ( 10.132000)
+# dalli get                      10.600000   0.000000  10.600000 ( 10.600000)
+#
+##############################################################################
+#
+# MBP 2.8G i7    jruby-memcached 0.1.0
+#
+# ruby-1.9.3-p194
+# ruby benchmark.rb
 #                                      user     system      total        real
-# dalli set                        8.400000   1.580000   9.980000 ( 10.139169)
-# dalli get                        8.500000   1.680000  10.180000 ( 10.287153)
+# memcached set                    1.110000   1.020000   2.130000 (  4.592509)
+# memcached get                    0.970000   1.000000   1.970000 (  4.172170)
 #                                      user     system      total        real
 # dalli set                        8.330000   1.560000   9.890000 ( 10.094499)
 # dalli get                        8.530000   1.680000  10.210000 ( 10.331083)
@@ -74,20 +99,8 @@ dalli.close
 # jruby-1.6.7.2
 # jruby --server -Ilib -S benchmark.rb
 #                                     user     system      total        real
-# jruby-memcached set             8.745000   0.000000   8.745000 (  8.745000)
-# jruby-memcached get             8.260000   0.000000   8.260000 (  8.260000)
-#                                     user     system      total        real
-# jruby-memcached set             6.911000   0.000000   6.911000 (  6.911000)
-# jruby-memcached get             6.895000   0.000000   6.895000 (  6.895000)
-#                                     user     system      total        real
 # jruby-memcached set             6.902000   0.000000   6.902000 (  6.902000)
 # jruby-memcached get             6.845000   0.000000   6.845000 (  6.845000)
 #                                     user     system      total        real
-# dalli set                      15.233000   0.000000  15.233000 ( 15.234000)
-# dalli get                      13.991000   0.000000  13.991000 ( 13.992000)
-#                                     user     system      total        real
-# dalli set                      12.936000   0.000000  12.936000 ( 12.936000)
-# dalli get                      13.585000   0.000000  13.585000 ( 13.585000)
-#                                     user     system      total        real
 # dalli set                      13.251000   0.000000  13.251000 ( 13.251000)
 # dalli get                      13.536000   0.000000  13.536000 ( 13.536000)

data/lib/memcached.rb

@@ -1,133 +1,5 @@
 require 'java'
 require 'memcached/version'
-require 'memcached/exceptions'
 require File.join(File.dirname(__FILE__), '../target/spymemcached-ext-0.0.1.jar')
 
-java_import 'net.spy.memcached.MemcachedClient'
-java_import 'net.spy.memcached.ConnectionFactoryBuilder'
-java_import 'net.spy.memcached.ConnectionFactoryBuilder$Locator'
-java_import 'net.spy.memcached.ConnectionFactoryBuilder$Protocol'
-java_import 'net.spy.memcached.DefaultHashAlgorithm'
-java_import 'net.spy.memcached.transcoders.SimpleTranscoder'
-java_import 'net.spy.memcached.AddrUtil'
-
-class Memcached
-
-  FLAGS = 0x0
-  DEFAULTS = {
-    :binary_protocol => false,
-    :default_ttl => 604800,
-    :distribution => :consistent_ketama,
-    :exception_retry_limit => 5,
-    :hash => :fnv1_32,
-  }
-
-  attr_reader :options
-  attr_reader :default_ttl
-
-  def initialize(addresses, options={})
-    @options = DEFAULTS.merge(options)
-    @default_ttl = @options[:default_ttl]
-
-    builder = ConnectionFactoryBuilder.new
-
-    @options[:distribution] = :consistent if @options[:distribution] == :ketama || @options[:distribution] == :consistent_ketama
-    unless [:array_mod, :consistent].include? @options[:distribution]
-      raise Memcached::NotSupport.new("#{@options[:distribution]} distribution algorithm doesn't support yet.")
-    end
-    distribution_algorithm = Locator.const_get @options[:distribution].to_s.upcase
-    builder.setLocatorType(distribution_algorithm)
-
-    if @options[:binary_protocol]
-      builder.setProtocol(Protocol::BINARY)
-    end
-
-    unless [:native, :crc, :fnv1_64, :fnv1a_64, :fnv1_32, :fnv1a_32, :ketama].include? @options[:hash]
-      raise Memcached::NotSupport.new("#{@options[:hash]} hash algorithm doesn't support yet.")
-    end
-    hash_algorithm = DefaultHashAlgorithm.const_get "#{@options[:hash]}_HASH".upcase
-    builder.setHashAlg hash_algorithm
-
-    @client = MemcachedClient.new builder.build, AddrUtil.getAddresses(Array(addresses).join(' '))
-
-    @simple_transcoder = SimpleTranscoder.new
-  end
-
-  def set(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
-    with_retry do
-      value = encode(value, marshal, flags)
-      @simple_transcoder.setFlags(flags)
-      @client.set(key, ttl, value.to_java_bytes, @simple_transcoder).get
-    end
-  end
-
-  def add(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
-    with_retry do
-      value = encode(value, marshal, flags)
-      @simple_transcoder.setFlags(flags)
-      if @client.add(key, ttl, value.to_java_bytes, @simple_transcoder).get === false
-        raise Memcached::NotStored
-      end
-    end
-  end
-
-  def replace(key, value, ttl=@default_ttl, marshal=true, flags=FLAGS)
-    with_retry do
-      value = encode(value, marshal, flags)
-      @simple_transcoder.setFlags(flags)
-      if @client.replace(key, ttl, value.to_java_bytes, @simple_transcoder).get === false
-        raise Memcached::NotStored
-      end
-    end
-  end
-
-  def delete(key)
-    with_retry do
-      raise Memcached::NotFound if @client.delete(key).get === false
-    end
-  end
-
-  def get(key, marshal=true)
-    with_retry do
-      ret = @client.get(key, @simple_transcoder)
-      raise Memcached::NotFound if ret.nil?
-      flags, data = ret.flags, ret.data
-      value = String.from_java_bytes data
-      value = decode(value, marshal, flags)
-    end
-  end
-
-  def flush
-    @client.flush.get
-  end
-
-  def servers
-    @client.available_servers.map { |address| address.to_s.split("/").last }
-  end
-
-  def close
-    @client.shutdown
-  end
-
-  alias_method :quit, :close
-
-  private
-  def with_retry
-    begin
-      yield
-    rescue
-      tries ||= 0
-      raise unless tries < options[:exception_retry_limit]
-      tries += 1
-      retry
-    end
-  end
-
-  def encode(value, marshal, flags)
-    marshal ? Marshal.dump(value) : value
-  end
-
-  def decode(value, marshal, flags)
-    marshal ? Marshal.load(value) : value
-  end
-end
+com.openfeint.memcached.MemcachedLibrary.new.load(JRuby.runtime, false)

data/lib/memcached/version.rb

@@ -1,3 +1,3 @@
 class Memcached
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/pom.xml

@@ -44,7 +44,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
-        <version>1.4</version>
+        <version>1.6</version>
         <executions>
           <execution>
             <phase>package</phase>

data/spec/memcached_spec.rb

@@ -1,30 +1,16 @@
 require 'spec_helper'
 
+com.openfeint.memcached.MemcachedLibrary.new.load(JRuby.runtime, false)
 describe Memcached do
   context "localhost" do
-    before(:all) { @memcached = Memcached.new("127.0.0.1:11211") }
-    after(:all) { @memcached.close }
+    before(:all) { @memcached = Memcached.new(["127.0.0.1:11211"]) }
+    after(:all) { @memcached.shutdown }
 
     it "should get all servers" do
       @memcached.servers.should == ["127.0.0.1:11211"]
     end
 
     context "initialize" do
-      before(:all) do
-        @memcached_with_options = Memcached.new("127.0.0.1:11211", :hash => :fnv1_32,
-                                                                   :distribution => :ketama,
-                                                                   :default_ttl => 900)
-      end
-      after(:all) { @memcached_with_options.close }
-
-      it "should with option hash" do
-        @memcached_with_options.options[:hash].should == :fnv1_32
-      end
-
-      it "should with option distribution" do
-        @memcached_with_options.options[:distribution].should == :consistent
-      end
-
       it "should raise error with unsupported option hash" do
         lambda { Memcached.new("127.0.0.1:11211", :hash => :unknown) }.should raise_error(Memcached::NotSupport)
       end
@@ -32,10 +18,6 @@ describe Memcached do
       it "should raise error with unsupported option distribution" do
         lambda { Memcached.new("127.0.0.1:11211", :distribution => :unknown) }.should raise_error(Memcached::NotSupport)
       end
-
-      it "should get default ttl" do
-        @memcached_with_options.default_ttl.should == 900
-      end
     end
 
     context "set/get" do
@@ -69,12 +51,6 @@ describe Memcached do
         sleep 1
         lambda { @memcached.get("key") }.should raise_error(Memcached::NotFound)
       end
-
-      it "should retry when set failure" do
-        Java::NetSpyMemcached::MemcachedClient.any_instance.stubs(:set).raises(Memcached::NotStored)
-        Java::NetSpyMemcachedTranscoders::SimpleTranscoder.any_instance.expects(:setFlags).times(6)
-        lambda { @memcached.set "key", "value" }.should raise_error(Memcached::NotStored)
-      end
     end
 
     context "add" do

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

@@ -0,0 +1,62 @@
+package com.openfeint.memcached;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import net.spy.memcached.CachedData;
+import net.spy.memcached.transcoders.Transcoder;
+import org.jruby.Ruby;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.marshal.MarshalStream;
+import org.jruby.runtime.marshal.UnmarshalStream;
+
+/**
+ *
+ * MarshalTranscoder does marshaling and unmarshaling.
+ *
+ */
+public class MarshalTranscoder implements Transcoder<IRubyObject> {
+    private 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(IRubyObject o) {
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            MarshalStream marshal = new MarshalStream(ruby, baos, Integer.MAX_VALUE);
+            marshal.dumpObject(o);
+            byte[] bytes = baos.toByteArray();
+            return new CachedData(getFlags(), bytes, bytes.length);
+        } catch (IOException ioe) {
+            throw ruby.newIOErrorFromException(ioe);
+        }
+    }
+
+    public IRubyObject decode(CachedData d) {
+        try {
+            return new UnmarshalStream(ruby, new ByteArrayInputStream(d.getData()), null, false, false).unmarshalObject();
+        } catch (IOException ioe) {
+            throw ruby.newIOErrorFromException(ioe);
+        }
+    }
+
+    public int getMaxSize() {
+        return CachedData.MAX_SIZE;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+}

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

@@ -0,0 +1,97 @@
+package com.openfeint.memcached;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
+import net.spy.memcached.CachedData;
+import net.spy.memcached.transcoders.Transcoder;
+import org.jruby.Ruby;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.marshal.MarshalStream;
+import org.jruby.runtime.marshal.UnmarshalStream;
+import org.jruby.util.ByteList;
+import com.jcraft.jzlib.ZOutputStream;
+import com.jcraft.jzlib.ZInputStream;
+import com.jcraft.jzlib.JZlib;
+
+/**
+ *
+ * MarshalZlibTranscoder do marshaling/unmarshaling and compressing/decompressing with zlib.
+ *
+ */
+public class MarshalZlibTranscoder implements Transcoder<IRubyObject> {
+    private Ruby ruby;
+    private int flags;
+
+    public MarshalZlibTranscoder(Ruby ruby) {
+        this(ruby, 1);
+    }
+
+    public MarshalZlibTranscoder(Ruby ruby, int flags) {
+        this.ruby = ruby;
+        this.flags = flags;
+    }
+
+    public boolean asyncDecode(CachedData d) {
+        return false;
+    }
+
+    public CachedData encode(IRubyObject o) {
+        try {
+            ByteArrayOutputStream out1 = new ByteArrayOutputStream();
+            MarshalStream marshal = new MarshalStream(ruby, out1, Integer.MAX_VALUE);
+            marshal.dumpObject(o);
+
+            byte[] bytes;
+            if (flags == 1) {
+                ByteArrayOutputStream out2 = new ByteArrayOutputStream();
+                ZOutputStream zout = new ZOutputStream(out2, JZlib.Z_DEFAULT_COMPRESSION);
+                zout.write(out1.toByteArray());
+                zout.close();
+                bytes = out2.toByteArray();
+            } else {
+                bytes = out1.toByteArray();
+            }
+
+            return new CachedData(getFlags(), bytes, bytes.length);
+        } catch (IOException ioe) {
+            throw ruby.newIOErrorFromException(ioe);
+        }
+    }
+
+    public IRubyObject decode(CachedData d) {
+        try {
+            byte[] bytes;
+            if (d.getFlags() == 1) {
+              ByteArrayInputStream in = new ByteArrayInputStream(d.getData());
+              ZInputStream 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();
+              zin.close();
+            } else {
+              bytes = d.getData();
+            }
+
+            return new UnmarshalStream(ruby, new ByteArrayInputStream(bytes), null, false, false).unmarshalObject();
+        } catch (IOException ioe) {
+            throw ruby.newIOErrorFromException(ioe);
+        }
+    }
+
+    public int getMaxSize() {
+        return CachedData.MAX_SIZE;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+}

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

@@ -0,0 +1,325 @@
+package com.openfeint.memcached;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import net.spy.memcached.AddrUtil;
+import net.spy.memcached.CachedData;
+import net.spy.memcached.ConnectionFactoryBuilder;
+import net.spy.memcached.ConnectionFactoryBuilder.Locator;
+import net.spy.memcached.ConnectionFactoryBuilder.Protocol;
+import net.spy.memcached.DefaultHashAlgorithm;
+import net.spy.memcached.MemcachedClient;
+import net.spy.memcached.transcoders.Transcoder;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyHash;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class Memcached extends RubyObject {
+    private Ruby ruby;
+
+    private MemcachedClient client;
+
+    private Transcoder<IRubyObject> transcoder;
+
+    private int ttl;
+
+    public Memcached(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+        this.ruby = ruby;
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject servers) {
+        return initialize(context, servers, context.nil);
+    }
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject servers, IRubyObject options) {
+        List<InetSocketAddress> addresses;
+        if ("java.lang.String".equals(servers.getJavaClass().getName())) {
+            addresses = AddrUtil.getAddresses(servers.convertToString().toString());
+        } else {
+            addresses = AddrUtil.getAddresses((List<String>)servers.convertToArray());
+        }
+        try {
+            ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
+
+            String distributionValue = null;
+            String hashValue = null;
+            String binaryValue = null;
+            String defaultTTL = null;
+            String transcoderValue = null;
+            if (!options.isNil()) {
+              RubyHash opts = options.convertToHash();
+              if (opts.containsKey(ruby.newSymbol("distribution"))) {
+                distributionValue = opts.get(ruby.newSymbol("distribution")).toString();
+              }
+              if (opts.containsKey(ruby.newSymbol("hash"))) {
+                hashValue = opts.get(ruby.newSymbol("hash")).toString();
+              }
+              if (opts.containsKey(ruby.newSymbol("binary_protocol"))) {
+                binaryValue = opts.get(ruby.newSymbol("binary_protocol")).toString();
+              }
+              if (opts.containsKey(ruby.newSymbol("default_ttl"))) {
+                defaultTTL = opts.get(ruby.newSymbol("default_ttl")).toString();
+              }
+              if (opts.containsKey(ruby.newSymbol("transcoder"))) {
+                transcoderValue = opts.get(ruby.newSymbol("transcoder")).toString();
+              }
+            }
+
+            if (distributionValue == null) {
+                distributionValue = "ketama";
+            }
+            if ("array_mod".equals(distributionValue)) {
+                builder.setLocatorType(Locator.ARRAY_MOD);
+            } else if ("ketama".equals(distributionValue) || "consistent_ketama".equals(distributionValue)) {
+                builder.setLocatorType(Locator.CONSISTENT);
+            } else {
+                throw newNotSupport(ruby, "distribution not support");
+            }
+
+            if (hashValue == null) {
+                hashValue = "fnv1_32";
+            }
+            if ("native".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.NATIVE_HASH);
+            } else if ("crc".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.CRC_HASH);
+            } else if ("fnv1_64".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.FNV1_64_HASH);
+            } else if ("fnv1a_64".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.FNV1A_64_HASH);
+            } else if ("fnv1_32".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.FNV1_32_HASH);
+            } else if ("fnv1a_32".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.FNV1A_32_HASH);
+            } else if ("ketama".equals(hashValue)) {
+                builder.setHashAlg(DefaultHashAlgorithm.KETAMA_HASH);
+            } else {
+                throw newNotSupport(ruby, "hash not support");
+            }
+
+            if ("true".equals(binaryValue)) {
+                builder.setProtocol(Protocol.BINARY);
+            }
+
+            if (defaultTTL == null) {
+                ttl = 604800;
+            } else {
+                ttl = Integer.parseInt(defaultTTL);
+            }
+
+            client = new MemcachedClient(builder.build(), addresses);
+
+            if ("marshal_zlib".equals(transcoderValue)) {
+              transcoder = new MarshalZlibTranscoder(ruby);
+            } else {
+              transcoder = new MarshalTranscoder(ruby);
+            }
+        } catch (IOException ioe) {
+            throw context.runtime.newIOErrorFromException(ioe);
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject servers(ThreadContext context) {
+        List<IRubyObject> addresses = new ArrayList<IRubyObject>();
+        for (SocketAddress address : client.getAvailableServers()) {
+            String addressStr = address.toString();
+            if (addressStr.indexOf("/") == 0) {
+                addressStr = addressStr.replace("/", "");
+            }
+            addresses.add(ruby.newString(addressStr));
+        }
+        return ruby.newArray(addresses);
+    }
+
+    @JRubyMethod
+    public IRubyObject add(ThreadContext context, IRubyObject key, IRubyObject value) {
+        return add(context, key, value, ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject add(ThreadContext context, IRubyObject key, IRubyObject value, IRubyObject timeout) {
+        try {
+            boolean result = client.add(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            if (result == false) {
+                throw newNotStored(ruby, "not stored");
+            }
+            return context.nil;
+        } catch (ExecutionException ee) {
+            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+        } catch (InterruptedException ie) {
+            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject replace(ThreadContext context, IRubyObject key, IRubyObject value) {
+        return replace(context, key, value, ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject replace(ThreadContext context, IRubyObject key, IRubyObject value, IRubyObject timeout) {
+        try {
+            boolean result = client.replace(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            if (result == false) {
+                throw newNotStored(ruby, "not stored");
+            }
+            return context.nil;
+        } catch (ExecutionException ee) {
+            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+        } catch (InterruptedException ie) {
+            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject set(ThreadContext context, IRubyObject key, IRubyObject value) {
+        return set(context, key, value, ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject set(ThreadContext context, IRubyObject key, IRubyObject value, IRubyObject timeout) {
+        try {
+            boolean result = client.set(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            if (result == false) {
+                throw newNotStored(ruby, "not stored");
+            }
+            return context.nil;
+        } catch (ExecutionException ee) {
+            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+        } catch (InterruptedException ie) {
+            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context, IRubyObject key) {
+        IRubyObject value = client.get(key.toString(), transcoder);
+        if (value == null) {
+          throw newNotFound(ruby, "not found");
+        }
+        return value;
+    }
+
+    @JRubyMethod
+    public  IRubyObject incr(ThreadContext context, IRubyObject key) {
+        return incr(context, key, ruby.newFixnum(1), ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject incr(ThreadContext context, IRubyObject key, IRubyObject by) {
+        return incr(context, key, by, ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject incr(ThreadContext context, IRubyObject key, IRubyObject by, IRubyObject timeout) {
+        long result = client.incr(key.toString(), (int)by.convertToInteger().getLongValue(), 1, (int)timeout.convertToInteger().getLongValue());
+        return ruby.newFixnum(result);
+    }
+
+    @JRubyMethod
+    public IRubyObject decr(ThreadContext context, IRubyObject key) {
+        return decr(context, key, ruby.newFixnum(1), ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject decr(ThreadContext context, IRubyObject key, IRubyObject by) {
+        return decr(context, key, by, ruby.newFixnum(ttl));
+    }
+
+    @JRubyMethod
+    public IRubyObject decr(ThreadContext context, IRubyObject key, IRubyObject by, IRubyObject timeout) {
+        long result = client.decr(key.toString(), (int)by.convertToInteger().getLongValue(), 0, (int)timeout.convertToInteger().getLongValue());
+        return ruby.newFixnum(result);
+    }
+
+    @JRubyMethod
+    public IRubyObject delete(ThreadContext context, IRubyObject key) {
+        try {
+            boolean result = client.delete(key.toString()).get();
+            if (result == false) {
+                throw newNotFound(ruby, "not found");
+            }
+            return context.nil;
+        } catch (ExecutionException ee) {
+            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+        } catch (InterruptedException ie) {
+            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject flush(ThreadContext context) {
+        try {
+            client.flush().get();
+            return context.nil;
+        } catch (ExecutionException ee) {
+            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+        } catch (InterruptedException ie) {
+            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject stats(ThreadContext context) {
+        RubyHash results = RubyHash.newHash(ruby);
+        for(Map.Entry<SocketAddress, Map<String, String>> entry : client.getStats().entrySet()) {
+            RubyHash serverHash = RubyHash.newHash(ruby);
+            for(Map.Entry<String, String> server : entry.getValue().entrySet()) {
+                serverHash.op_aset(context, ruby.newString(server.getKey()), ruby.newString(server.getValue()));
+            }
+            results.op_aset(context, ruby.newString(entry.getKey().toString()), serverHash);
+        }
+        return results;
+    }
+
+    @JRubyMethod
+    public IRubyObject shutdown(ThreadContext context) {
+        client.shutdown();
+
+        return context.nil;
+    }
+
+    @JRubyClass(name="Memcached::Error", parent="RuntimeError")
+    public static class Error {}
+    @JRubyClass(name="Memcached::NotFound", parent="Memcached::Error")
+    public static class NotFound extends Error {}
+    @JRubyClass(name="Memcached::NotStored", parent="Memcached::Error")
+    public static class NotStored extends Error {}
+    @JRubyClass(name="Memcached::NotSupport", parent="Memcached::Error")
+    public static class NotSupport extends Error {}
+
+    static RaiseException newNotFound(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotFound", message);
+    }
+
+    static RaiseException newNotStored(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotStored", message);
+    }
+
+    static RaiseException newNotSupport(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotSupport", 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/MemcachedLibrary.java

@@ -0,0 +1,52 @@
+package com.openfeint.memcached;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import net.spy.memcached.CachedData;
+import net.spy.memcached.MemcachedClient;
+import net.spy.memcached.transcoders.Transcoder;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyHash;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+import org.jruby.runtime.marshal.MarshalStream;
+import org.jruby.runtime.marshal.UnmarshalStream;
+
+public class MemcachedLibrary implements Library {
+    private Ruby ruby;
+
+    public void load(final Ruby ruby, boolean bln) throws IOException {
+        this.ruby = ruby;
+
+        RubyClass memcached = ruby.defineClass("Memcached", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new Memcached(ruby, rc);
+            }
+        });
+
+        memcached.defineAnnotatedMethods(Memcached.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());
+    }
+}

metadata

@@ -2,7 +2,7 @@
 name: jruby-memcached
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
   - Richard Huang
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-29 00:00:00 Z
+date: 2012-08-07 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rspec
@@ -58,9 +58,11 @@ files:
   - pom.xml
   - spec/memcached_spec.rb
   - spec/spec_helper.rb
+  - src/main/java/com/openfeint/memcached/MarshalTranscoder.java
+  - src/main/java/com/openfeint/memcached/MarshalZlibTranscoder.java
+  - src/main/java/com/openfeint/memcached/Memcached.java
+  - src/main/java/com/openfeint/memcached/MemcachedLibrary.java
   - src/main/java/net/spy/memcached/KetamaNodeLocator.java
-  - src/main/java/net/spy/memcached/ReturnData.java
-  - src/main/java/net/spy/memcached/transcoders/SimpleTranscoder.java
   - src/main/java/net/spy/memcached/util/DefaultKetamaNodeLocatorConfiguration.java
   - target/spymemcached-ext-0.0.1.jar
 homepage: https://github.com/aurorafeint/jruby-memcached
@@ -86,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: jruby compatible memcached client

data/src/main/java/net/spy/memcached/ReturnData.java

@@ -1,20 +0,0 @@
-package net.spy.memcached;
-
-public class ReturnData {
-    private int flags;
-    private byte[] data;
-
-    public ReturnData(int flags, byte[] data) {
-        this.flags = flags;
-        this.data = data;
-    }
-
-
-    public int getFlags() {
-        return flags;
-    }
-
-    public byte[] getData() {
-        return data;
-    }
-}

data/src/main/java/net/spy/memcached/transcoders/SimpleTranscoder.java

@@ -1,53 +0,0 @@
-package net.spy.memcached.transcoders;
-
-import net.spy.memcached.CachedData;
-import net.spy.memcached.ReturnData;
-import net.spy.memcached.transcoders.Transcoder;
-
-/**
- *
- * SimpleTranscoder didn't do any serializing/deserializing or compression/decompression.
- * Ruby will convert object to string by Marshal and finally passing bytes[].
- *
- */
-public class SimpleTranscoder implements Transcoder<Object> {
-    private final int maxSize;
-    private int flags;
-
-    public SimpleTranscoder() {
-        this(CachedData.MAX_SIZE, 0);
-    }
-
-    public SimpleTranscoder(int flags) {
-        this(CachedData.MAX_SIZE, flags);
-    }
-
-    public SimpleTranscoder(int maxSize, int flags) {
-        this.maxSize = maxSize;
-        this.flags = flags;
-    }
-
-    public boolean asyncDecode(CachedData d) {
-        return false;
-    }
-
-    public CachedData encode(Object o) {
-        return new CachedData(getFlags(), (byte[]) o, getMaxSize());
-    }
-
-    public Object decode(CachedData d) {
-        return new ReturnData(d.getFlags(), d.getData());
-    }
-
-    public int getMaxSize() {
-        return maxSize;
-    }
-
-    public int getFlags() {
-        return flags;
-    }
-
-    public void setFlags(int flags) {
-        this.flags = flags;
-    }
-}