jruby-memcached 0.3.0 → 0.4.0

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+## 0.4.0 (Aug 16, 2012)
+
+Bugfixes:
+
+  - set as daemon thread to avoid suspend ruby process (like rake task)
+
+Features:
+
+  - support get with multiple keys
+  - add Memcached::Rails as rails cache_store
+  - use jruby annotation to reduce method definitions
+
+## 0.3.0 (Aug 7, 2012)
+
+Features:
+
+  - rewrite with pure jruby implementation
+
+## 0.2.0 (Jul 29, 2012)
+
+Bugfixes:
+
+  - set method should not be async
+
+Features:
+
+  - allow to change hash, distribution and binary protocol
+
+## 0.1.0 (Jul 24, 2012)
+
+Features:
+
+  - wrap java library spymemcached
+  - compatible hash and distribution algorithms with memcached.gem

data/Gemfile.lock

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

data/README.md

@@ -35,11 +35,16 @@ You can get multiple values at once:
     $cache.get ['test', 'test2', 'missing']
       #=> {"test" => "hello", "test2" => "hello"}
 
+## Rails
+
+  # config/environment.rb
+  config.cache_store = Memcached::Rails.new(:servers => ['127.0.0.1'])
+
 ## Benchmarks
 
 memcached.gem is the fastest memcached gem in MRI,
 jruby-memcached is the fastest memcached gem in JRuby.
 See [benchmark][1]
 
-[0]:"https://github.com/evan/memcached"
-[1]:"https://github.com/aurorafeint/jruby-memcached/blob/master/benchmark.rb"
+[0]: https://github.com/evan/memcached
+[1]: https://github.com/aurorafeint/jruby-memcached/blob/master/benchmark.rb

data/lib/memcached.rb

@@ -1,5 +1,12 @@
 require 'java'
 require 'memcached/version'
 require File.join(File.dirname(__FILE__), '../target/spymemcached-ext-0.0.1.jar')
+require 'com/openfeint/memcached/memcached'
 
-com.openfeint.memcached.MemcachedLibrary.new.load(JRuby.runtime, false)
+class Memcached::Rails
+  attr_reader :logger
+
+  def logger=(logger)
+    @logger = logger
+  end
+end

data/lib/memcached/version.rb

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

data/spec/memcached_spec.rb

@@ -1,16 +1,23 @@
 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.shutdown }
 
     it "should get all servers" do
+      @memcached.set "foo", "bar"
       @memcached.servers.should == ["127.0.0.1:11211"]
     end
 
     context "initialize" do
+      it "should connect to 127.0.0.1:11211 if no server defined" do
+        memcached = Memcached.new
+        memcached.set "foo", "bar"
+        memcached.servers.should == ["127.0.0.1:11211"]
+        memcached.shutdown
+      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
@@ -42,6 +49,24 @@ describe Memcached do
         @memcached.delete "key" rescue nil
         lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
       end
+
+      context "multiget" do
+        it "should get hash containing multiple key/value pairs" do
+          @memcached.set "key1", "value1"
+          @memcached.set "key2", "value2"
+          @memcached.get(["key1", "key2"]).should == {"key1" => "value1", "key2" => "value2"}
+        end
+
+        it "should get hash containing nil value" do
+          @memcached.set "key", nil, 0
+          @memcached.get(["key"]).should == {"key" => nil}
+        end
+
+        it "should get empty hash" do
+          @memcached.delete "key" rescue nil
+          @memcached.get(["key"]).should be_empty
+        end
+      end
     end
 
     context "set" do
@@ -99,6 +124,14 @@ describe Memcached do
         @memcached.delete "key" rescue nil
         lambda { @memcached.delete "key" }.should raise_error(Memcached::NotFound)
       end
+
+      #context "incr/decr" do
+        #it "should incr key" do
+          #@memcached.incr "intkey"
+          #@memcached.incr "intkey"
+          #@memcached.get("intkey").should == 1
+        #end
+      #end
     end
 
     context "flush" do
@@ -110,5 +143,50 @@ describe Memcached do
         lambda { @memcached.get "key2" }.should raise_error(Memcached::NotFound)
       end
     end
+
+    context "namespace/prefix_key" do
+      it "should get/set with namespace" do
+        memcached = Memcached.new("127.0.0.1:11211", :namespace => "jruby")
+        memcached.set "key", "value"
+        memcached.get("key").should == "value"
+        memcached.shutdown
+        @memcached.get("jrubykey").should == "value"
+      end
+
+      context "prefix_key" do
+        before(:all) { @prefix_memcached = Memcached.new("127.0.0.1:11211", :prefix_key => "jruby") }
+        after(:all) { @prefix_memcached.shutdown }
+
+        it "should get/set with prefix_key" do
+          @prefix_memcached.set "key", "value"
+          @prefix_memcached.get("key").should == "value"
+          @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"
+          @memcached.get("jrubynewkey").should == "new_value"
+        end
+
+        it "should delete with prefix_key" do
+          @prefix_memcached.set "key", "value"
+          @prefix_memcached.delete "key"
+          lambda { @memcached.get("jrubykey") }.should raise_error(Memcached::NotFound)
+        end
+
+        it "should multiget with prefix_key" do
+          @prefix_memcached.set "key1", "value1"
+          @prefix_memcached.set "key2", "value2"
+          @prefix_memcached.get(["key1", "key2"]).should == {"key1" => "value1", "key2" => "value2"}
+        end
+      end
+    end
   end
 end

data/spec/rails_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Memcached::Rails do
+  context "localhost" do
+    before(:all) { @memcached = Memcached::Rails.new(:servers => ["127.0.0.1:11211"]) }
+    after(:all) { @memcached.shutdown }
+
+    it "should get all servers" do
+      @memcached.set "foo", "bar"
+      @memcached.servers.should == ["127.0.0.1:11211"]
+    end
+
+    it "should get logger" do
+      require 'logger'
+      @memcached.logger = Logger.new(STDOUT)
+      @memcached.logger.should_not be_nil
+    end
+
+    it "should be active" do
+      @memcached.should be_active
+    end
+
+    context "get" do
+      it "should get value" do
+        @memcached.set "key", "value"
+        @memcached.get("key").should == "value"
+      end
+
+      it "should get nil if key is missing" do
+        @memcached.delete "key" rescue nil
+        @memcached.get("key").should be_nil
+      end
+    end
+
+    context "read" do
+      it "should get value" do
+        @memcached.set "key", "value"
+        @memcached.get("key").should == "value"
+      end
+
+      it "should get nil if key is missing" do
+        @memcached.delete "key" rescue nil
+        @memcached.get("key").should be_nil
+      end
+    end
+
+    context "exist?" do
+      it "should return true if key exists" do
+        @memcached.set "key", "value"
+        @memcached.exist?("key").should be_true
+      end
+
+      it "should return false if key is missing" do
+        @memcached.delete "key" rescue nil
+        @memcached.exist?("key").should be_false
+      end
+    end
+
+    context "get_multi" do
+      it "should get hash containing multiple key/value pairs" do
+        @memcached.set "key1", "value1"
+        @memcached.set "key2", "value2"
+        @memcached.get(["key1", "key2"]).should == {"key1" => "value1", "key2" => "value2"}
+      end
+
+      it "should get hash containing nil value" do
+        @memcached.set "key", nil, 0
+        @memcached.get(["key"]).should == {"key" => nil}
+      end
+
+      it "should get empty hash" do
+        @memcached.delete "key" rescue nil
+        @memcached.get(["key"]).should be_empty
+      end
+    end
+
+    context "set" do
+      it "should set successfully" do
+        @memcached.set("key", "value").should be_true
+        @memcached.get("key").should == "value"
+      end
+    end
+
+    context "write" do
+      it "should write successfully" do
+        @memcached.write("key", "value").should be_true
+        @memcached.read("key").should == "value"
+      end
+    end
+
+    context "fetch" do
+      it "should read if key exists" do
+        @memcached.write("key", "value")
+        @memcached.fetch("key") { "new value" }.should == "value"
+      end
+
+      it "should write if key is missing" do
+        @memcached.delete "key" rescue nil
+        @memcached.fetch("key") { "new value" }.should == "new value"
+      end
+    end
+
+    context "add" do
+      it "should add if key is missing" do
+        @memcached.delete "key" rescue nil
+        @memcached.add("key", "value").should be_true
+      end
+
+      it "should do nothing if key exists" do
+        @memcached.set "key", "value"
+        @memcached.add("key", "value").should be_false
+      end
+
+      context "with string_return_types" do
+        before(:all) { @string_memcached = Memcached::Rails.new("127.0.0.1:11211", :string_return_types => true) }
+        after(:all) { @string_memcached.quit }
+
+        it "should add if key is missing" do
+          @string_memcached.delete "key" rescue nil
+          @string_memcached.add("key", "value").should == "STORED\r\n"
+        end
+
+        it "should do nothing if key exists" do
+          @string_memcached.set "key", "value"
+          @string_memcached.add("key", "value").should == "NOT STORED\r\n"
+        end
+      end
+    end
+
+    context "delete" do
+      it "should delete existing key" do
+        @memcached.set "key", "value"
+        @memcached.delete "key"
+        @memcached.get("key").should be_nil
+      end
+
+      it "should do nothing if delete missing key" do
+        @memcached.delete "key" rescue nil
+        @memcached.delete "key"
+        @memcached.get("key").should be_nil
+      end
+    end
+
+    context "alias" do
+      it "should respond_to? flush_all" do
+        @memcached.should be_respond_to(:flush_all)
+      end
+
+      it "should respond_to? clear" do
+        @memcached.should be_respond_to(:clear)
+      end
+
+      it "should respond_to? :[]" do
+        @memcached.should be_respond_to(:"[]")
+      end
+
+      it "should respond_to? :[]=" do
+        @memcached.should be_respond_to(:"[]=")
+      end
+    end
+
+    context "read_multi" do
+      it "should read hash containing multiple key/value pairs" do
+        @memcached.write "key1", "value1"
+        @memcached.write "key2", "value2"
+        @memcached.read_multi(["key1", "key2"]).should == {"key1" => "value1", "key2" => "value2"}
+      end
+
+      it "should read empty hash without params" do
+        @memcached.read_multi.should be_empty
+      end
+    end
+  end
+end

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

@@ -1,15 +1,9 @@
 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 com.openfeint.memcached.error.Error;
+import com.openfeint.memcached.transcoder.MarshalTranscoder;
+import com.openfeint.memcached.transcoder.MarshalZlibTranscoder;
 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;
@@ -17,127 +11,68 @@ import net.spy.memcached.DefaultHashAlgorithm;
 import net.spy.memcached.MemcachedClient;
 import net.spy.memcached.transcoders.Transcoder;
 import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
-import org.jruby.RubyException;
 import org.jruby.RubyHash;
 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;
 
-public class Memcached extends RubyObject {
-    private Ruby ruby;
+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;
 
+@JRubyClass(name = "Memcached")
+public class Memcached extends RubyObject {
     private MemcachedClient client;
 
     private Transcoder<IRubyObject> transcoder;
 
     private int ttl;
 
+    private String prefixKey;
+
     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);
+        ttl = 604800;
+        prefixKey = "";
     }
-    @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());
+
+    @JRubyMethod(name = "initialize", optional = 2)
+    public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        RubyHash options;
+        if (args.length > 1) {
+            options = args[1].convertToHash();
         } else {
-            addresses = AddrUtil.getAddresses((List<String>)servers.convertToArray());
+            options = new RubyHash(ruby);
         }
-        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";
+        List<String> servers = new ArrayList<String>();
+        if (args.length > 0) {
+            if (args[0] instanceof RubyString) {
+                servers.add(args[0].toString());
+            } else if (args[0] instanceof RubyArray) {
+                servers.addAll((List<String>) args[0].convertToArray());
             }
-            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;
+        if (servers.isEmpty()) {
+            servers.add("127.0.0.1:11211");
+        }
+        return init(context, servers, options);
     }
 
     @JRubyMethod
     public IRubyObject servers(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
         List<IRubyObject> addresses = new ArrayList<IRubyObject>();
         for (SocketAddress address : client.getAvailableServers()) {
             String addressStr = address.toString();
@@ -149,136 +84,139 @@ public class Memcached extends RubyObject {
         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) {
+    @JRubyMethod(name = "add", required = 2, optional = 3)
+    public IRubyObject add(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        String key = getFullKey(args[0].toString());
+        IRubyObject value = args[1];
+        int timeout = getTimeout(args);
         try {
-            boolean result = client.add(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            boolean result = client.add(key, timeout, value, transcoder).get();
             if (result == false) {
-                throw newNotStored(ruby, "not stored");
+                throw Error.newNotStored(ruby, "not stored");
             }
             return context.nil;
         } catch (ExecutionException ee) {
-            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+            throw ruby.newRuntimeError(ee.getLocalizedMessage());
         } catch (InterruptedException ie) {
-            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+            throw ruby.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) {
+    @JRubyMethod(name = "replace", required = 2, optional = 3)
+    public IRubyObject replace(ThreadContext context, IRubyObject [] args) {
+        Ruby ruby = context.getRuntime();
+        String key = getFullKey(args[0].toString());
+        IRubyObject value = args[1];
+        int timeout = getTimeout(args);
         try {
-            boolean result = client.replace(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            boolean result = client.replace(key, timeout, value, transcoder).get();
             if (result == false) {
-                throw newNotStored(ruby, "not stored");
+                throw Error.newNotStored(ruby, "not stored");
             }
             return context.nil;
         } catch (ExecutionException ee) {
-            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+            throw ruby.newRuntimeError(ee.getLocalizedMessage());
         } catch (InterruptedException ie) {
-            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+            throw ruby.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) {
+    @JRubyMethod(name = "set", required = 2, optional = 3)
+    public IRubyObject set(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        String key = getFullKey(args[0].toString());
+        IRubyObject value = args[1];
+        int timeout = getTimeout(args);
         try {
-            boolean result = client.set(key.toString(), (int)timeout.convertToInteger().getLongValue(), value, transcoder).get();
+            boolean result = client.set(key, timeout, value, transcoder).get();
             if (result == false) {
-                throw newNotStored(ruby, "not stored");
+                throw Error.newNotStored(ruby, "not stored");
             }
             return context.nil;
         } catch (ExecutionException ee) {
-            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+            throw ruby.newRuntimeError(ee.getLocalizedMessage());
         } catch (InterruptedException ie) {
-            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+            throw ruby.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");
+    @JRubyMethod(name = "get", required = 1, optional = 1)
+    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)));
+                }
+            }
+            return results;
         }
-        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));
+        return context.nil;
     }
 
-    @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());
+    @JRubyMethod(name = "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);
     }
 
-    @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());
+    @JRubyMethod(name = "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);
     }
 
     @JRubyMethod
     public IRubyObject delete(ThreadContext context, IRubyObject key) {
+        Ruby ruby = context.getRuntime();
         try {
-            boolean result = client.delete(key.toString()).get();
+            boolean result = client.delete(getFullKey(key.toString())).get();
             if (result == false) {
-                throw newNotFound(ruby, "not found");
+                throw Error.newNotFound(ruby, "not found");
             }
             return context.nil;
         } catch (ExecutionException ee) {
-            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+            throw ruby.newRuntimeError(ee.getLocalizedMessage());
         } catch (InterruptedException ie) {
-            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
     @JRubyMethod
     public IRubyObject flush(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
         try {
             client.flush().get();
             return context.nil;
         } catch (ExecutionException ee) {
-            throw context.runtime.newRuntimeError(ee.getLocalizedMessage());
+            throw ruby.newRuntimeError(ee.getLocalizedMessage());
         } catch (InterruptedException ie) {
-            throw context.runtime.newThreadError(ie.getLocalizedMessage());
+            throw ruby.newThreadError(ie.getLocalizedMessage());
         }
     }
 
     @JRubyMethod
     public IRubyObject stats(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
         RubyHash results = RubyHash.newHash(ruby);
         for(Map.Entry<SocketAddress, Map<String, String>> entry : client.getStats().entrySet()) {
             RubyHash serverHash = RubyHash.newHash(ruby);
@@ -290,36 +228,119 @@ public class Memcached extends RubyObject {
         return results;
     }
 
-    @JRubyMethod
+    @JRubyMethod(name = {"quit", "shutdown"})
     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);
+    protected int getDefaultTTL() {
+        return ttl;
     }
 
-    static RaiseException newNotStored(Ruby ruby, String message) {
-        return newMemcachedError(ruby, "NotStored", message);
+    protected IRubyObject init(ThreadContext context, List<String> servers, RubyHash options) {
+        Ruby ruby = context.getRuntime();
+        List<InetSocketAddress> addresses = AddrUtil.getAddresses(servers);
+        try {
+            ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
+
+            String distributionValue = "ketama";
+            String hashValue = "fnv1_32";
+            RubyBoolean binaryValue = ruby.getFalse();
+            String transcoderValue = null;
+            if (!options.isEmpty()) {
+                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 = (RubyBoolean) opts.get(ruby.newSymbol("binary_protocol"));
+                }
+                if (opts.containsKey(ruby.newSymbol("default_ttl"))) {
+                    ttl = Integer.parseInt(opts.get(ruby.newSymbol("default_ttl")).toString());
+                }
+                if (opts.containsKey(ruby.newSymbol("namespace"))) {
+                    prefixKey = opts.get(ruby.newSymbol("namespace")).toString();
+                }
+                if (opts.containsKey(ruby.newSymbol("prefix_key"))) {
+                    prefixKey = opts.get(ruby.newSymbol("prefix_key")).toString();
+                }
+                if (opts.containsKey(ruby.newSymbol("transcoder"))) {
+                    transcoderValue = opts.get(ruby.newSymbol("transcoder")).toString();
+                }
+            }
+
+            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 Error.newNotSupport(ruby, "distribution not support");
+            }
+            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 Error.newNotSupport(ruby, "hash not support");
+            }
+
+            if (ruby.getTrue() == binaryValue) {
+                builder.setProtocol(Protocol.BINARY);
+            }
+
+            builder.setDaemon(true);
+            client = new MemcachedClient(builder.build(), addresses);
+
+            if ("marshal_zlib".equals(transcoderValue)) {
+              transcoder = new MarshalZlibTranscoder(ruby);
+            } else {
+              transcoder = new MarshalTranscoder(ruby);
+            }
+        } catch (IOException ioe) {
+            throw ruby.newIOErrorFromException(ioe);
+        }
+
+        return context.nil;
+    }
+
+    private int getTimeout(IRubyObject[] args) {
+        if (args.length > 2) {
+            return (int) args[2].convertToInteger().getLongValue();
+        }
+        return ttl;
     }
 
-    static RaiseException newNotSupport(Ruby ruby, String message) {
-        return newMemcachedError(ruby, "NotSupport", message);
+    private int getIncrDecrBy(IRubyObject[] args) {
+        if (args.length > 1) {
+            return (int) args[1].convertToInteger().getLongValue();
+        }
+        return 1;
+    }
+
+    private List<String> getFullKeys(List<String> keys) {
+        List<String> fullKeys = new ArrayList<String>();
+        for (String key : keys) {
+            fullKeys.add(getFullKey(key));
+        }
+        return fullKeys;
     }
 
-    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);
+    private String getFullKey(String key) {
+        return prefixKey + key;
     }
 }