jruby-memcached-thoughtworks 0.6.0

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/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,104 @@
+--- !ruby/object:Gem::Specification
+name: jruby-memcached-thoughtworks
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Bill DePhillips
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: jruby memcacached client which is compatible with memcached gem
+email:
+- bill.dephillips@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- benchmark.rb
+- jruby_memcached.gemspec
+- lib/memcached.rb
+- lib/memcached/version.rb
+- pom.xml
+- spec/memcached_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- spec/timeout_spec.rb
+- 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
+- src/main/java/com/openfeint/memcached/error/NotSupport.java
+- src/main/java/com/openfeint/memcached/transcoder/MarshalTranscoder.java
+- src/main/java/com/openfeint/memcached/transcoder/MarshalZlibTranscoder.java
+- src/main/java/net/spy/memcached/KetamaNodeLocator.java
+- src/main/java/net/spy/memcached/util/DefaultKetamaNodeLocatorConfiguration.java
+- target/spymemcached-ext-0.0.2.jar
+homepage: https://github.com/ThoughtWorksStudios/jruby-memcached
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: jruby compatible memcached client
+test_files:
+- spec/memcached_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- spec/timeout_spec.rb