jruby-memcached 0.4.1 → 0.5.0

data/Gemfile

@@ -2,3 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in jruby-memcached.gemspec
 gemspec
+
+gem "rake"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jruby-memcached (0.4.1)
+    jruby-memcached (0.5.0)
 
 GEM
   remote: http://rubygems.org/
@@ -10,6 +10,7 @@ GEM
     metaclass (0.0.1)
     mocha (0.12.1)
       metaclass (~> 0.0.1)
+    rake (0.9.2.2)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
       rspec-expectations (~> 2.11.0)
@@ -25,4 +26,5 @@ PLATFORMS
 DEPENDENCIES
   jruby-memcached!
   mocha
+  rake
   rspec

data/Rakefile

@@ -1,2 +1,16 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require "rake"
+require "rspec"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "memcached/version"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec
+task :test => :spec

data/benchmark.rb

@@ -52,10 +52,8 @@ dalli = Dalli::Client.new(['localhost:11211'])
   }
 }
 
-if JRUBY
-  memcached.shutdown
-  spymemcached.shutdown
-end
+memcached.quit
+spymemcached.shutdown if JRUBY
 dalli.close
 
 # I run benchmark for each client 3 times, but only list the last result for each.

data/lib/memcached/version.rb

@@ -1,3 +1,3 @@
 class Memcached
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/pom.xml

@@ -35,7 +35,7 @@
     <dependency>
       <groupId>spy</groupId>
       <artifactId>spymemcached</artifactId>
-      <version>2.8.1</version>
+      <version>2.8.3</version>
     </dependency>
   </dependencies>
 

data/spec/memcached_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Memcached do
   context "localhost" do
     before(:all) { @memcached = Memcached.new(["127.0.0.1:11211"]) }
-    after(:all) { @memcached.shutdown }
+    after(:all) { @memcached.quit }
 
     it "should get all servers" do
       @memcached.set "foo", "bar"
@@ -124,14 +124,51 @@ describe Memcached do
         @memcached.delete "key" rescue nil
         lambda { @memcached.delete "key" }.should raise_error(Memcached::NotFound)
       end
+    end
+
+    context "increment" do
+      it "should increment to default value" do
+        @memcached.delete "intkey" rescue nil
+        @memcached.increment "intkey"
+        @memcached.get("intkey").should == 1
+      end
+
+      it "should increment by 1" do
+        @memcached.delete "intkey" rescue nil
+        @memcached.increment "intkey"
+        @memcached.increment "intkey"
+        @memcached.get("intkey").should == 2
+      end
 
-      #context "incr/decr" do
-        #it "should incr key" do
-          #@memcached.incr "intkey"
-          #@memcached.incr "intkey"
-          #@memcached.get("intkey").should == 1
-        #end
-      #end
+      it "should increment by 10" do
+        @memcached.delete "intkey" rescue nil
+        @memcached.increment "intkey"
+        @memcached.increment "intkey", 10
+        @memcached.get("intkey").should == 11
+      end
+    end
+
+    context "decrement" do
+      it "should decrement to default value" do
+        @memcached.delete "intkey" rescue nil
+        @memcached.decrement "intkey"
+        @memcached.get("intkey").should == 0
+      end
+
+      it "should decrement by 1" do
+        @memcached.delete "intkey" rescue nil
+        2.times { @memcached.increment "intkey" }
+        @memcached.decrement "intkey"
+        @memcached.get("intkey").should == 1
+      end
+
+      it "should decrement by 10" do
+        @memcached.delete "intkey" rescue nil
+        @memcached.increment "intkey"
+        @memcached.increment "intkey", 20
+        @memcached.decrement "intkey", 10
+        @memcached.get("intkey").should == 11
+      end
     end
 
     context "flush" do
@@ -163,12 +200,6 @@ describe Memcached do
           @memcached.get("jrubykey").should == "value"
         end
 
-        #it "should incr/decr with prefix_key" do
-          #@prefix_memcached.incr "intkey"
-          #@prefix_memcached.decr "intkey"
-          #@memcached.get("jrubyintkey").should == 0
-        #end
-
         it "should add/replace with prefix_key" do
           @prefix_memcached.add "newkey", "value"
           @prefix_memcached.replace "newkey", "new_value"
@@ -186,6 +217,57 @@ describe Memcached do
           @prefix_memcached.set "key2", "value2"
           @prefix_memcached.get(["key1", "key2"]).should == {"key1" => "value1", "key2" => "value2"}
         end
+
+        it "should increment/decrement with prefix_key" do
+          @prefix_memcached.delete "intkey" rescue nil
+          @prefix_memcached.increment "intkey"
+          @prefix_memcached.increment "intkey", 10
+          @prefix_memcached.decrement "intkey", 5
+          @memcached.get("jrubyintkey").should == 6
+        end
+      end
+    end
+
+    context "timeout" do
+      before(:all) do
+        @memcached = Memcached.new("127.0.0.1:11211")
+        @timeout_memcached = Memcached.new("127.0.0.1:11211", :timeout => 1, :exception_retry_limit => 0)
+      end
+      after(:all) do
+        @timeout_memcached.quit
+        @memcached.quit
+      end
+
+      it "should set timeout" do
+        lambda { @timeout_memcached.set "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should add timeout" do
+        @memcached.delete "key" rescue nil
+        lambda { @timeout_memcached.add "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should replace timeout" do
+        @memcached.set "key", "value"
+        lambda { @timeout_memcached.replace "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should delete timeout" do
+        @memcached.set "key", "value"
+        lambda { @timeout_memcached.delete "key" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should get timeout" do
+        @memcached.set "key", "value"
+        lambda { @timeout_memcached.get "key" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should increment timeout" do
+        lambda { @timeout_memcached.increment "intkey" }.should raise_error(Memcached::ATimeoutOccurred)
+      end
+
+      it "should decrement timeout" do
+        lambda { @timeout_memcached.decrement "intkey" }.should raise_error(Memcached::ATimeoutOccurred)
       end
     end
   end

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

@@ -1,6 +1,7 @@
 package com.openfeint.memcached;
 
 import com.openfeint.memcached.error.Error;
+import com.openfeint.memcached.error.NotFound;
 import com.openfeint.memcached.transcoder.MarshalTranscoder;
 import com.openfeint.memcached.transcoder.MarshalZlibTranscoder;
 import net.spy.memcached.AddrUtil;
@@ -9,6 +10,7 @@ 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.OperationTimeoutException;
 import net.spy.memcached.transcoders.Transcoder;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -19,6 +21,7 @@ import org.jruby.RubyObject;
 import org.jruby.RubyString;
 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;
 
@@ -34,16 +37,22 @@ import java.util.concurrent.ExecutionException;
 public class Memcached extends RubyObject {
     private MemcachedClient client;
 
-    private Transcoder<IRubyObject> transcoder;
+    private Transcoder transcoder;
 
     private int ttl;
 
+    private int timeout;
+
+    private int exceptionRetryLimit;
+
     private String prefixKey;
 
     public Memcached(final Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
 
         ttl = 604800;
+        timeout = -1;
+        exceptionRetryLimit = 5;
         prefixKey = "";
     }
 
@@ -89,17 +98,41 @@ public class Memcached extends RubyObject {
         Ruby ruby = context.getRuntime();
         String key = getFullKey(args[0].toString());
         IRubyObject value = args[1];
-        int timeout = getTimeout(args);
-        try {
-            boolean result = client.add(key, timeout, value, transcoder).get();
-            if (result == false) {
-                throw Error.newNotStored(ruby, "not stored");
+        int expiry = getExpiry(args);
+        int retry = 0;
+        while (true) {
+            try {
+                boolean result = (Boolean) client.add(key, expiry, value, transcoder).get();
+                if (result == false) {
+                    throw Error.newNotStored(ruby, "not stored");
+                }
+                return context.nil;
+            } catch (RaiseException e) {
+                throw e;
+            } catch (ExecutionException e) {
+                if ("net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (RuntimeException e) {
+                if (e.getCause() != null &&
+                    "net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (InterruptedException e) {
+                throw ruby.newThreadError(e.getLocalizedMessage());
             }
-            return context.nil;
-        } catch (ExecutionException ee) {
-            throw ruby.newRuntimeError(ee.getLocalizedMessage());
-        } catch (InterruptedException ie) {
-            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
@@ -108,17 +141,41 @@ public class Memcached extends RubyObject {
         Ruby ruby = context.getRuntime();
         String key = getFullKey(args[0].toString());
         IRubyObject value = args[1];
-        int timeout = getTimeout(args);
-        try {
-            boolean result = client.replace(key, timeout, value, transcoder).get();
-            if (result == false) {
-                throw Error.newNotStored(ruby, "not stored");
+        int expiry = getExpiry(args);
+        int retry = 0;
+        while (true) {
+            try {
+                boolean result = (Boolean) client.replace(key, expiry, value, transcoder).get();
+                if (result == false) {
+                    throw Error.newNotStored(ruby, "not stored");
+                }
+                return context.nil;
+            } catch (RaiseException e) {
+                throw e;
+            } catch (ExecutionException e) {
+                if ("net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (RuntimeException e) {
+                if (e.getCause() != null &&
+                    "net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (InterruptedException e) {
+                throw ruby.newThreadError(e.getLocalizedMessage());
             }
-            return context.nil;
-        } catch (ExecutionException ee) {
-            throw ruby.newRuntimeError(ee.getLocalizedMessage());
-        } catch (InterruptedException ie) {
-            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
@@ -127,17 +184,41 @@ public class Memcached extends RubyObject {
         Ruby ruby = context.getRuntime();
         String key = getFullKey(args[0].toString());
         IRubyObject value = args[1];
-        int timeout = getTimeout(args);
-        try {
-            boolean result = client.set(key, timeout, value, transcoder).get();
-            if (result == false) {
-                throw Error.newNotStored(ruby, "not stored");
+        int expiry = getExpiry(args);
+        int retry = 0;
+        while (true) {
+            try {
+                boolean result = (Boolean) client.set(key, expiry, value, transcoder).get();
+                if (result == false) {
+                    throw Error.newNotStored(ruby, "not stored");
+                }
+                return context.nil;
+            } catch (RaiseException e) {
+                throw e;
+            } catch (ExecutionException e) {
+                if ("net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (RuntimeException e) {
+                if (e.getCause() != null &&
+                    "net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (InterruptedException e) {
+                throw ruby.newThreadError(e.getLocalizedMessage());
             }
-            return context.nil;
-        } catch (ExecutionException ee) {
-            throw ruby.newRuntimeError(ee.getLocalizedMessage());
-        } catch (InterruptedException ie) {
-            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
@@ -145,59 +226,122 @@ public class Memcached extends RubyObject {
     public IRubyObject get(ThreadContext context, IRubyObject[] args) {
         Ruby ruby = context.getRuntime();
         IRubyObject keys = args[0];
-        if (keys instanceof RubyString) {
-            IRubyObject value = client.get(getFullKey(keys.toString()), transcoder);
-            if (value == null) {
-                throw Error.newNotFound(ruby, "not found");
-            }
-            return value;
-        } else if (keys instanceof RubyArray) {
-            RubyHash results = RubyHash.newHash(ruby);
-
-            Map<String, IRubyObject> bulkResults = client.getBulk(getFullKeys(keys.convertToArray()), transcoder);
-            for (String key : (List<String>) keys.convertToArray()) {
-                if (bulkResults.containsKey(getFullKey(key))) {
-                    results.put(key, bulkResults.get(getFullKey(key)));
+        int retry = 0;
+        while (true) {
+            try {
+                if (keys instanceof RubyString) {
+                    Object ret = client.get(getFullKey(keys.toString()), transcoder);
+                    if (ret == null) {
+                        throw Error.newNotFound(ruby, "not found");
+                    }
+                    IRubyObject value;
+                    if (ret instanceof IRubyObject) {
+                        value = (IRubyObject) ret;
+                    } else {
+                        value = ruby.newFixnum((Long) ret);
+                    }
+                    return value;
+                } else if (keys instanceof RubyArray) {
+                    RubyHash results = RubyHash.newHash(ruby);
+
+                    Map<String, IRubyObject> bulkResults = client.getBulk(getFullKeys(keys.convertToArray()), transcoder);
+                    for (String key : (List<String>) keys.convertToArray()) {
+                        if (bulkResults.containsKey(getFullKey(key))) {
+                            results.put(key, (IRubyObject) bulkResults.get(getFullKey(key)));
+                        }
+                    }
+                    return results;
                 }
+            } catch (RaiseException e) {
+                throw e;
+            } catch (OperationTimeoutException e) {
+                throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+            } catch (RuntimeException e) {
+                throw ruby.newRuntimeError(e.getLocalizedMessage());
             }
-            return results;
+            return context.nil;
         }
-        return context.nil;
     }
 
-    @JRubyMethod(name = "incr", required = 1, optional = 2)
+    @JRubyMethod(name = { "increment", "incr" }, required = 1, optional = 2)
     public IRubyObject incr(ThreadContext context, IRubyObject[] args) {
         Ruby ruby = context.getRuntime();
         String key = getFullKey(args[0].toString());
         int by = getIncrDecrBy(args);
-        int timeout = getTimeout(args);
-        long result = client.incr(key, by, 1, timeout);
-        return ruby.newFixnum(result);
+        int expiry = getExpiry(args);
+        int retry = 0;
+        while (true) {
+            try {
+                long result = client.incr(key, by, 1, expiry);
+                return ruby.newFixnum(result);
+            } catch (OperationTimeoutException e) {
+                if (retry == exceptionRetryLimit) {
+                    throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                }
+                retry++;
+                continue;
+            }
+        }
     }
 
-    @JRubyMethod(name = "decr", required = 1, optional = 2)
+    @JRubyMethod(name = { "decrement", "decr" }, required = 1, optional = 2)
     public IRubyObject decr(ThreadContext context, IRubyObject[] args) {
         Ruby ruby = context.getRuntime();
         String key = getFullKey(args[0].toString());
         int by = getIncrDecrBy(args);
-        int timeout = getTimeout(args);
-        long result = client.decr(key, by, 0, timeout);
-        return ruby.newFixnum(result);
+        int expiry = getExpiry(args);
+        int retry = 0;
+        while (true) {
+            try {
+                long result = client.decr(key, by, 0, expiry);
+                return ruby.newFixnum(result);
+            } catch (OperationTimeoutException e) {
+                if (retry == exceptionRetryLimit) {
+                    throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                }
+                retry++;
+                continue;
+            }
+        }
     }
 
-    @JRubyMethod
+    @JRubyMethod(name = "delete")
     public IRubyObject delete(ThreadContext context, IRubyObject key) {
         Ruby ruby = context.getRuntime();
-        try {
-            boolean result = client.delete(getFullKey(key.toString())).get();
-            if (result == false) {
-                throw Error.newNotFound(ruby, "not found");
+        int retry = 0;
+        while (true) {
+            try {
+                boolean result = client.delete(getFullKey(key.toString())).get();
+                if (result == false) {
+                    throw Error.newNotFound(ruby, "not found");
+                }
+                return context.nil;
+            } catch (RaiseException e) {
+                throw e;
+            } catch (ExecutionException e) {
+                if ("net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (RuntimeException e) {
+                if (e.getCause() != null &&
+                    "net.spy.memcached.internal.CheckedOperationTimeoutException".equals(e.getCause().getClass().getName())) {
+                    if (retry == exceptionRetryLimit) {
+                        throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                    }
+                    retry++;
+                    continue;
+                } else {
+                    throw ruby.newRuntimeError(e.getLocalizedMessage());
+                }
+            } catch (InterruptedException e) {
+                throw ruby.newThreadError(e.getLocalizedMessage());
             }
-            return context.nil;
-        } catch (ExecutionException ee) {
-            throw ruby.newRuntimeError(ee.getLocalizedMessage());
-        } catch (InterruptedException ie) {
-            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
@@ -207,10 +351,12 @@ public class Memcached extends RubyObject {
         try {
             client.flush().get();
             return context.nil;
-        } catch (ExecutionException ee) {
-            throw ruby.newRuntimeError(ee.getLocalizedMessage());
-        } catch (InterruptedException ie) {
-            throw ruby.newThreadError(ie.getLocalizedMessage());
+        } catch (OperationTimeoutException e) {
+            throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+        } catch (ExecutionException e) {
+            throw ruby.newRuntimeError(e.getLocalizedMessage());
+        } catch (InterruptedException e) {
+            throw ruby.newThreadError(e.getLocalizedMessage());
         }
     }
 
@@ -248,6 +394,7 @@ public class Memcached extends RubyObject {
             String distributionValue = "ketama";
             String hashValue = "fnv1_32";
             RubyBoolean binaryValue = ruby.getFalse();
+            RubyBoolean shouldOptimize = ruby.getFalse();
             String transcoderValue = null;
             if (!options.isEmpty()) {
                 RubyHash opts = options.convertToHash();
@@ -260,9 +407,18 @@ public class Memcached extends RubyObject {
                 if (opts.containsKey(ruby.newSymbol("binary_protocol"))) {
                     binaryValue = (RubyBoolean) opts.get(ruby.newSymbol("binary_protocol"));
                 }
+                if (opts.containsKey(ruby.newSymbol("should_optimize"))) {
+                    shouldOptimize = (RubyBoolean) opts.get(ruby.newSymbol("should_optimize"));
+                }
                 if (opts.containsKey(ruby.newSymbol("default_ttl"))) {
                     ttl = Integer.parseInt(opts.get(ruby.newSymbol("default_ttl")).toString());
                 }
+                if (opts.containsKey(ruby.newSymbol("timeout"))) {
+                    timeout = Integer.parseInt(opts.get(ruby.newSymbol("timeout")).toString());
+                }
+                if (opts.containsKey(ruby.newSymbol("exception_retry_limit"))) {
+                    exceptionRetryLimit = Integer.parseInt(opts.get(ruby.newSymbol("exception_retry_limit")).toString());
+                }
                 if (opts.containsKey(ruby.newSymbol("namespace"))) {
                     prefixKey = opts.get(ruby.newSymbol("namespace")).toString();
                 }
@@ -302,15 +458,22 @@ public class Memcached extends RubyObject {
             if (ruby.getTrue() == binaryValue) {
                 builder.setProtocol(Protocol.BINARY);
             }
+            if (ruby.getTrue() == shouldOptimize) {
+                builder.setShouldOptimize(true);
+            }
 
+            if (timeout != -1) {
+                builder.setOpTimeout(timeout);
+            }
             builder.setDaemon(true);
-            client = new MemcachedClient(builder.build(), addresses);
-
             if ("marshal_zlib".equals(transcoderValue)) {
                 transcoder = new MarshalZlibTranscoder(ruby);
             } else {
                 transcoder = new MarshalTranscoder(ruby);
             }
+            builder.setTranscoder(transcoder);
+
+            client = new MemcachedClient(builder.build(), addresses);
         } catch (IOException ioe) {
             throw ruby.newIOErrorFromException(ioe);
         }
@@ -318,7 +481,7 @@ public class Memcached extends RubyObject {
         return context.nil;
     }
 
-    private int getTimeout(IRubyObject[] args) {
+    private int getExpiry(IRubyObject[] args) {
         if (args.length > 2) {
             return (int) args[2].convertToInteger().getLongValue();
         }

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

@@ -29,6 +29,7 @@ public class MemcachedService implements BasicLibraryService {
         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/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

@@ -20,6 +20,10 @@ public class Error {
         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/transcoder/MarshalTranscoder.java

@@ -3,6 +3,7 @@ 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;
@@ -16,8 +17,8 @@ import java.io.IOException;
  * MarshalTranscoder does marshaling and unmarshaling.
  *
  */
-public class MarshalTranscoder implements Transcoder<IRubyObject> {
-    private Ruby ruby;
+public class MarshalTranscoder implements Transcoder {
+    protected Ruby ruby;
     private int flags;
 
     public MarshalTranscoder(Ruby ruby) {
@@ -33,23 +34,29 @@ public class MarshalTranscoder implements Transcoder<IRubyObject> {
         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 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 IRubyObject decode(CachedData d) {
+    public Object decode(CachedData d) {
         try {
             return new UnmarshalStream(ruby, new ByteArrayInputStream(d.getData()), null, false, false).unmarshalObject();
-        } catch (IOException ioe) {
-            throw ruby.newIOErrorFromException(ioe);
+        } catch (RaiseException e) {
+            return decodeNumber(d, e);
+        } catch (IOException e) {
+            return decodeNumber(d, e);
         }
     }
 
@@ -60,4 +67,25 @@ public class MarshalTranscoder implements Transcoder<IRubyObject> {
     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

@@ -6,6 +6,7 @@ import com.jcraft.jzlib.JZlib;
 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;
@@ -22,77 +23,69 @@ import java.io.IOException;
  * MarshalZlibTranscoder do marshaling/unmarshaling and compressing/decompressing with zlib.
  *
  */
-public class MarshalZlibTranscoder implements Transcoder<IRubyObject> {
-    private Ruby ruby;
-    private int flags;
+public class MarshalZlibTranscoder extends MarshalTranscoder {
+    static final int COMPRESS_FLAG = 1;
 
     public MarshalZlibTranscoder(Ruby ruby) {
-        this(ruby, 1);
+        super(ruby, COMPRESS_FLAG);
     }
 
     public MarshalZlibTranscoder(Ruby ruby, int flags) {
-        this.ruby = ruby;
-        this.flags = flags;
+        super(ruby, flags);
     }
 
-    public boolean asyncDecode(CachedData d) {
-        return false;
-    }
+    public CachedData encode(Object o) {
+        if (o instanceof IRubyObject) {
+            try {
+                ByteArrayOutputStream out1 = new ByteArrayOutputStream();
+                MarshalStream marshal = new MarshalStream(ruby, out1, Integer.MAX_VALUE);
+                marshal.dumpObject((IRubyObject) o);
 
-    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 (getFlags() == COMPRESS_FLAG) {
+                    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();
+                }
 
-            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(super.getFlags(), bytes, bytes.length);
+            } catch (IOException e) {
+                throw ruby.newIOErrorFromException(e);
             }
-
-            return new CachedData(getFlags(), bytes, bytes.length);
-        } catch (IOException ioe) {
-            throw ruby.newIOErrorFromException(ioe);
+        } else {
+            return super.encodeNumber(o);
         }
     }
 
-    public IRubyObject decode(CachedData d) {
+    public Object decode(CachedData d) {
         try {
             byte[] bytes;
-            if (d.getFlags() == 1) {
-              ByteArrayInputStream in = new ByteArrayInputStream(d.getData());
-              ZInputStream zin = new ZInputStream(in);
+            if (d.getFlags() == COMPRESS_FLAG) {
+                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();
+                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();
+                bytes = d.getData();
             }
 
             return new UnmarshalStream(ruby, new ByteArrayInputStream(bytes), null, false, false).unmarshalObject();
-        } catch (IOException ioe) {
-            throw ruby.newIOErrorFromException(ioe);
+        } catch (RaiseException e) {
+            return super.decodeNumber(d, e);
+        } catch (IOException e) {
+            return super.decodeNumber(d, e);
         }
     }
-
-    public int getMaxSize() {
-        return CachedData.MAX_SIZE;
-    }
-
-    public int getFlags() {
-        return flags;
-    }
 }

metadata

@@ -2,7 +2,7 @@
 name: jruby-memcached
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
   - Richard Huang
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-17 00:00:00 Z
+date: 2012-08-22 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rspec
@@ -63,6 +63,7 @@ files:
   - src/main/java/com/openfeint/memcached/Memcached.java
   - src/main/java/com/openfeint/memcached/MemcachedService.java
   - src/main/java/com/openfeint/memcached/Rails.java
+  - src/main/java/com/openfeint/memcached/error/ATimeoutOccurred.java
   - src/main/java/com/openfeint/memcached/error/Error.java
   - src/main/java/com/openfeint/memcached/error/NotFound.java
   - src/main/java/com/openfeint/memcached/error/NotStored.java