jruby-memcached 0.1.0

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+target/classes
+target/maven-archiver
+target/surefire
+target/dependency-reduced-pom.xml
+target/original-spymemcached-ext-0.0.1.jar
+target/original-xmemcached-ext-0.0.1.jar

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jruby-memcached.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    jruby-memcached (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    metaclass (0.0.1)
+    mocha (0.12.1)
+      metaclass (~> 0.0.1)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  jruby-memcached!
+  mocha
+  rspec

data/README.md

@@ -0,0 +1,7 @@
+jruby-memcached
+===============
+
+we used memcached gem before, but now we are migrating to jruby, but
+memcached didn't support jruby platform, and we can't find any
+ruby/jruby gem that compatible with memcached, have to write it by
+ourselves.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/benchmark.rb

@@ -0,0 +1,93 @@
+require 'benchmark'
+
+JRUBY = defined?(JRUBY_VERSION)
+
+if JRUBY
+  require 'lib/memcached'
+else
+  require 'memcached'
+end
+require 'rubygems'
+require 'dalli'
+
+memcached = Memcached.new(['localhost:11211'])
+dalli = Dalli::Client.new(['localhost:11211'])
+
+3.to_i.times {
+  Benchmark.bm(30) {|bm|
+    if JRUBY
+      bm.report("jruby-memcached set") {
+        100_000.times { memcached.set('foo', 'bar').get }
+      }
+      bm.report("jruby-memcached get") {
+        100_000.times { memcached.get('foo') }
+      }
+    else
+      bm.report("memcached set") {
+        100_000.times { memcached.set('foo', 'bar') }
+      }
+      bm.report("memcached get") {
+        100_000.times { memcached.get('foo') }
+      }
+    end
+  }
+}
+
+3.times {
+  Benchmark.bm(30) {|bm|
+    bm.report("dalli set") {
+      100_000.times { dalli.set('foo', 'bar') }
+    }
+    bm.report("dalli get") {
+      100_000.times { dalli.get('foo') }
+    }
+  }
+}
+
+memcached.close
+dalli.close
+
+
+# MBP 2.8G i7
+#
+# 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)
+#                                      user     system      total        real
+# dalli set                        8.400000   1.580000   9.980000 ( 10.139169)
+# dalli get                        8.500000   1.680000  10.180000 ( 10.287153)
+#                                      user     system      total        real
+# dalli set                        8.330000   1.560000   9.890000 ( 10.094499)
+# dalli get                        8.530000   1.680000  10.210000 ( 10.331083)
+#
+# 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/jruby_memcached.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "memcached/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jruby-memcached"
+  s.version     = Memcached::VERSION
+  s.authors     = ["Richard Huang"]
+  s.email       = ["flyerhzm@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{jruby compatible memcached client}
+  s.description = %q{jruby memcacached client which is compatible with memcached gem}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mocha'
+end

data/lib/memcached/exceptions.rb

@@ -0,0 +1,3 @@
+class Memcached::Error < RuntimeError; end
+class Memcached::NotFound < Memcached::Error; end
+class Memcached::NotStored < Memcached::Error; end

data/lib/memcached/version.rb

@@ -0,0 +1,3 @@
+class Memcached
+  VERSION = "0.1.0"
+end

data/lib/memcached.rb

@@ -0,0 +1,114 @@
+  require 'java'
+require 'memcached/version'
+require 'memcached/exceptions'
+require File.join(File.dirname(__FILE__), '../target/spymemcached-ext-0.0.1.jar')
+
+class Memcached
+  include_class 'java.net.InetSocketAddress'
+  include_class 'net.spy.memcached.MemcachedClient'
+  include_class 'net.spy.memcached.ConnectionFactoryBuilder'
+  include_class 'net.spy.memcached.ConnectionFactoryBuilder$Locator'
+  include_class 'net.spy.memcached.DefaultHashAlgorithm'
+  include_class 'net.spy.memcached.FailureMode'
+  include_class 'net.spy.memcached.transcoders.SimpleTranscoder'
+  include_class 'net.spy.memcached.AddrUtil'
+
+  FLAGS = 0x0
+  DEFAULTS = {
+    :default_ttl => 604800,
+    :exception_retry_limit => 5
+  }
+
+  attr_reader :options
+  attr_reader :default_ttl
+
+  def initialize(addresses, options={})
+    builder = ConnectionFactoryBuilder.new.
+                                       setLocatorType(Locator::CONSISTENT).
+                                       setHashAlg(DefaultHashAlgorithm::FNV1_32_HASH)
+    @client = MemcachedClient.new builder.build, AddrUtil.getAddresses(Array(addresses).join(' '))
+
+    @options = DEFAULTS.merge(options)
+    @default_ttl = @options[:default_ttl]
+
+    @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)
+    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

data/pom.xml

@@ -0,0 +1,66 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>net.spy</groupId>
+  <artifactId>spymemcached-ext</artifactId>
+  <version>0.0.1</version>
+  <packaging>jar</packaging>
+
+  <name>spymemcached-ext</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <repositories>
+    <repository>
+      <id>spymemcached</id>
+      <name>spymemcached extention</name>
+      <layout>default</layout>
+      <url>http://files.couchbase.com/maven2/</url>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+    </repository>
+  </repositories>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby</artifactId>
+      <version>1.6.7.2</version>
+    </dependency>
+    <dependency>
+      <groupId>spy</groupId>
+      <artifactId>spymemcached</artifactId>
+      <version>2.8.1</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>1.4</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <artifactSet>
+                <excludes>
+                  <exclude>org.jruby:jruby</exclude>
+                </excludes>
+              </artifactSet>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

data/spec/memcached_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Memcached do
+  context "localhost" do
+    before :all do
+      @memcached = Memcached.new("127.0.0.1:11211")
+    end
+
+    after :all do
+      @memcached.close
+    end
+
+    it "should initialize with options" do
+      @memcached.servers.should == ["127.0.0.1:11211"]
+    end
+
+    context "set/get" do
+      it "should set/get with plain text" do
+        @memcached.set "key", "value"
+        @memcached.get("key").should == "value"
+      end
+
+      it "should set/get with compressed text" do
+        @memcached.set "key", "x\234c?P?*?/?I\001\000\b8\002a"
+        @memcached.get("key").should == "x\234c?P?*?/?I\001\000\b8\002a"
+      end
+    end
+
+    context "get" do
+      it "should get nil" do
+        @memcached.set "key", nil, 0
+        @memcached.get("key").should be_nil
+      end
+
+      it "should get missing" do
+        @memcached.delete "key" rescue nil
+        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+      end
+    end
+
+    context "set" do
+      it "should set expiry" do
+        @memcached.set "key", "value", 1
+        @memcached.get("key").should == "value"
+        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
+      it "should add new key" do
+        @memcached.delete "key" rescue nil
+        @memcached.add "key", "value"
+        @memcached.get("key").should == "value"
+      end
+
+      it "should not add existing key" do
+        @memcached.set "key", "value"
+        lambda { @memcached.add "key", "value" }.should raise_error(Memcached::NotStored)
+      end
+
+      it "should add expiry" do
+        @memcached.delete "key" rescue nil
+        @memcached.add "key", "value", 1
+        @memcached.get "key"
+        sleep 1
+        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+      end
+    end
+
+    context "replace" do
+      it "should replace existing key" do
+        @memcached.set "key", nil
+        @memcached.replace "key", "value"
+        @memcached.get("key").should == "value"
+      end
+
+      it "should not replace with new key" do
+        @memcached.delete "key" rescue nil
+        lambda { @memcached.replace "key", "value" }.should raise_error(Memcached::NotStored)
+        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+      end
+    end
+
+    context "delete" do
+      it "should delete with existing key" do
+        @memcached.set "key", "value"
+        @memcached.delete "key"
+        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+      end
+
+      it "should not delete with new key" do
+        @memcached.delete "key" rescue nil
+        lambda { @memcached.delete "key" }.should raise_error(Memcached::NotFound)
+      end
+    end
+
+    context "flush" do
+      it "should flush all keys" do
+        @memcached.set "key1", "value2"
+        @memcached.set "key2", "value2"
+        @memcached.flush
+        lambda { @memcached.get "key1" }.should raise_error(Memcached::NotFound)
+        lambda { @memcached.get "key2" }.should raise_error(Memcached::NotFound)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'rspec/autorun'
+
+require 'memcached'
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

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

@@ -0,0 +1,165 @@
+package net.spy.memcached;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import net.spy.memcached.compat.SpyObject;
+import net.spy.memcached.util.DefaultKetamaNodeLocatorConfiguration;
+import net.spy.memcached.util.KetamaNodeLocatorConfiguration;
+
+/**
+ * This is grabbed from spymemcached.
+ *
+ * hashAlg should only be used to get server by key.
+ *
+ */
+public final class KetamaNodeLocator extends SpyObject implements NodeLocator {
+
+  private volatile TreeMap<Long, MemcachedNode> ketamaNodes;
+  private final Collection<MemcachedNode> allNodes;
+
+  private final HashAlgorithm hashAlg;
+  private final KetamaNodeLocatorConfiguration config;
+
+  /**
+   * Create a new KetamaNodeLocator using specified nodes and the specifed hash
+   * algorithm.
+   *
+   * @param nodes The List of nodes to use in the Ketama consistent hash
+   *          continuum
+   * @param alg The hash algorithm to use when choosing a node in the Ketama
+   *          consistent hash continuum
+   */
+  public KetamaNodeLocator(List<MemcachedNode> nodes, HashAlgorithm alg) {
+    this(nodes, alg, new DefaultKetamaNodeLocatorConfiguration());
+  }
+
+  /**
+   * Create a new KetamaNodeLocator using specified nodes and the specifed hash
+   * algorithm and configuration.
+   *
+   * @param nodes The List of nodes to use in the Ketama consistent hash
+   *          continuum
+   * @param alg The hash algorithm to use when choosing a node in the Ketama
+   *          consistent hash continuum
+   * @param conf
+   */
+  public KetamaNodeLocator(List<MemcachedNode> nodes, HashAlgorithm alg,
+      KetamaNodeLocatorConfiguration conf) {
+    super();
+    allNodes = nodes;
+    hashAlg = alg;
+    config = conf;
+    setKetamaNodes(nodes);
+  }
+
+  private KetamaNodeLocator(TreeMap<Long, MemcachedNode> smn,
+      Collection<MemcachedNode> an, HashAlgorithm alg,
+      KetamaNodeLocatorConfiguration conf) {
+    super();
+    ketamaNodes = smn;
+    allNodes = an;
+    hashAlg = alg;
+    config = conf;
+  }
+
+  public Collection<MemcachedNode> getAll() {
+    return allNodes;
+  }
+
+  public MemcachedNode getPrimary(final String k) {
+    MemcachedNode rv = getNodeForKey(hashAlg.hash(k));
+    assert rv != null : "Found no node for key " + k;
+    return rv;
+  }
+
+  long getMaxKey() {
+    return getKetamaNodes().lastKey();
+  }
+
+  MemcachedNode getNodeForKey(long hash) {
+    final MemcachedNode rv;
+    if (!ketamaNodes.containsKey(hash)) {
+      // Java 1.6 adds a ceilingKey method, but I'm still stuck in 1.5
+      // in a lot of places, so I'm doing this myself.
+      SortedMap<Long, MemcachedNode> tailMap = getKetamaNodes().tailMap(hash);
+      if (tailMap.isEmpty()) {
+        hash = getKetamaNodes().firstKey();
+      } else {
+        hash = tailMap.firstKey();
+      }
+    }
+    rv = getKetamaNodes().get(hash);
+    return rv;
+  }
+
+  public Iterator<MemcachedNode> getSequence(String k) {
+    // Seven searches gives us a 1 in 2^7 chance of hitting the
+    // same dead node all of the time.
+    return new KetamaIterator(k, 7, getKetamaNodes(), hashAlg);
+  }
+
+  public NodeLocator getReadonlyCopy() {
+    TreeMap<Long, MemcachedNode> smn =
+        new TreeMap<Long, MemcachedNode>(getKetamaNodes());
+    Collection<MemcachedNode> an =
+        new ArrayList<MemcachedNode>(allNodes.size());
+
+    // Rewrite the values a copy of the map.
+    for (Map.Entry<Long, MemcachedNode> me : smn.entrySet()) {
+      me.setValue(new MemcachedNodeROImpl(me.getValue()));
+    }
+
+    // Copy the allNodes collection.
+    for (MemcachedNode n : allNodes) {
+      an.add(new MemcachedNodeROImpl(n));
+    }
+
+    return new KetamaNodeLocator(smn, an, hashAlg, config);
+  }
+
+  @Override
+  public void updateLocator(List<MemcachedNode> nodes) {
+    setKetamaNodes(nodes);
+  }
+
+  /**
+   * @return the ketamaNodes
+   */
+  protected TreeMap<Long, MemcachedNode> getKetamaNodes() {
+    return ketamaNodes;
+  }
+
+  /**
+   * Setup the KetamaNodeLocator with the list of nodes it should use.
+   *
+   * @param nodes a List of MemcachedNodes for this KetamaNodeLocator to use in
+   *          its continuum
+   */
+  protected void setKetamaNodes(List<MemcachedNode> nodes) {
+    TreeMap<Long, MemcachedNode> newNodeMap =
+        new TreeMap<Long, MemcachedNode>();
+    int numReps = config.getNodeRepetitions();
+    for (MemcachedNode node : nodes) {
+      for (int i = 0; i < numReps / 4; i++) {
+        byte[] digest =
+            DefaultHashAlgorithm.computeMd5(config.getKeyForNode(node, i));
+        for (int h = 0; h < 4; h++) {
+          Long k = ((long) (digest[3 + h * 4] & 0xFF) << 24)
+                  | ((long) (digest[2 + h * 4] & 0xFF) << 16)
+                  | ((long) (digest[1 + h * 4] & 0xFF) << 8)
+                  | (digest[h * 4] & 0xFF);
+          newNodeMap.put(k, node);
+          getLogger().debug("Adding node %s in position %d", node, k);
+        }
+      }
+    }
+    assert newNodeMap.size() == numReps * nodes.size();
+    ketamaNodes = newNodeMap;
+  }
+}

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,56 @@
+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) {
+        byte[] b = (byte[]) o;
+        return new CachedData(getFlags(), b, getMaxSize());
+    }
+
+    public Object decode(CachedData d) {
+        byte[] data = d.getData();
+        int flags = d.getFlags();
+        return new ReturnData(flags, data);
+    }
+
+    public int getMaxSize() {
+        return maxSize;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+
+    public void setFlags(int flags) {
+        this.flags = flags;
+    }
+}

data/src/main/java/net/spy/memcached/util/DefaultKetamaNodeLocatorConfiguration.java

@@ -0,0 +1,104 @@
+package net.spy.memcached.util;
+
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.spy.memcached.MemcachedNode;
+
+/**
+ * This is grabbed from spymemcached.
+ *
+ * socket address in libmemcached 0.32 is
+ *   127.0.0.1-1 (port is 11211) or
+ *   127.0.0.1:43043-1 (port is not 11211)
+ */
+public class DefaultKetamaNodeLocatorConfiguration implements
+    KetamaNodeLocatorConfiguration {
+
+  private final int numReps = 160;
+  static final int DEFAULT_PORT = 11211;
+
+  // Internal lookup map to try to carry forward the optimisation that was
+  // previously in KetamaNodeLocator
+  protected Map<MemcachedNode, String> socketAddresses =
+      new HashMap<MemcachedNode, String>();
+
+  /**
+   * Returns the socket address of a given MemcachedNode.
+   *
+   * @param node The node which we're interested in
+   * @return String the socket address of that node.
+   */
+  protected String getSocketAddressForNode(MemcachedNode node) {
+    // Using the internal map retrieve the socket addresses
+    // for given nodes.
+    // I'm aware that this code is inherently thread-unsafe as
+    // I'm using a HashMap implementation of the map, but the worst
+    // case ( I believe) is we're slightly in-efficient when
+    // a node has never been seen before concurrently on two different
+    // threads, so it the socketaddress will be requested multiple times!
+    // all other cases should be as fast as possible.
+    String result = socketAddresses.get(node);
+    if (result == null) {
+      InetSocketAddress socketAddress = (InetSocketAddress) node.getSocketAddress();
+      if (socketAddress.getPort() == DEFAULT_PORT) {
+        result = socketAddress.getAddress().getHostAddress();
+      } else {
+        result = socketAddress.getAddress().getHostAddress() + ":" + socketAddress.getPort();
+      }
+      socketAddresses.put(node, result);
+    }
+    return result;
+  }
+
+  /**
+   * Returns the number of discrete hashes that should be defined for each node
+   * in the continuum.
+   *
+   * @return NUM_REPS repetitions.
+   */
+  public int getNodeRepetitions() {
+    return numReps;
+  }
+
+  /**
+   * Returns a uniquely identifying key, suitable for hashing by the
+   * KetamaNodeLocator algorithm.
+   *
+   * <p>
+   * This default implementation uses the socket-address of the MemcachedNode
+   * and concatenates it with a hyphen directly against the repetition number
+   * for example a key for a particular server's first repetition may look like:
+   * <p>
+   *
+   * <p>
+   * <code>myhost/10.0.2.1-0</code>
+   * </p>
+   *
+   * <p>
+   * for the second repetition
+   * </p>
+   *
+   * <p>
+   * <code>myhost/10.0.2.1-1</code>
+   * </p>
+   *
+   * <p>
+   * for a server where reverse lookups are failing the returned keys may look
+   * like
+   * </p>
+   *
+   * <p>
+   * <code>/10.0.2.1-0</code> and <code>/10.0.2.1-1</code>
+   * </p>
+   *
+   * @param node The MemcachedNode to use to form the unique identifier
+   * @param repetition The repetition number for the particular node in question
+   *          (0 is the first repetition)
+   * @return The key that represents the specific repetition of the node
+   */
+  public String getKeyForNode(MemcachedNode node, int repetition) {
+    return getSocketAddressForNode(node) + "-" + repetition;
+  }
+}

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-memcached
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - Richard Huang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-24 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: mocha
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id002
+description: jruby memcacached client which is compatible with memcached gem
+email: 
+  - flyerhzm@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - Gemfile
+  - Gemfile.lock
+  - README.md
+  - Rakefile
+  - benchmark.rb
+  - jruby_memcached.gemspec
+  - lib/memcached.rb
+  - lib/memcached/exceptions.rb
+  - lib/memcached/version.rb
+  - pom.xml
+  - spec/memcached_spec.rb
+  - spec/spec_helper.rb
+  - 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: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: jruby compatible memcached client
+test_files: 
+  - spec/memcached_spec.rb
+  - spec/spec_helper.rb