binary42-fastcache 0.1 → 0.2

data/benchmark/basic.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'fastcache'
+require 'memcache'
+require 'benchmark'
+
+NODE = ['localhost:11211']
+
+n = 1000
+Benchmark.bm(30) do |x|
+  x.report 'basic operations - memcache-client' do
+    conn = MemCache.new(*NODE)
+    n.times do
+      conn.get('f')
+      conn.set('f', '42')
+      conn.get('f')
+      conn.delete('f')
+    end
+    conn.reset
+  end
+  x.report 'basic operations - fastcache' do
+    conn = FastCache.connect(NODE)
+    n.times do
+      conn.get('f')
+      conn.set('f', '42')
+      conn.get('f')
+      conn.delete('f')
+    end
+    conn.close_all_connections
+  end
+end

data/lib/fastcache.rb

@@ -14,7 +14,7 @@ require 'fastcache/hash/sha1'
 
 # Key routers
 # TODO: Check for ruby-ketama
-require 'fastcache/router/basic'
+require 'fastcache/routing/basic_router'
 
 # Networking and protocol support code
 require 'fastcache/memcache'
@@ -32,9 +32,10 @@ class << FastCache
       :type => 'raw'
     }.merge(opts)
 
-    connections[opts[:name]].close if connections[opts[:name]]
+    connections[opts[:name]].close_all_connections if connections[opts[:name]]
 
-    nodes = node_list.split(',').map {|node|
+    node_list = node_list.split(',') if String === node_list
+    nodes = node_list.map {|node|
       host, port = *node.split(':')
       port ||= 80
       [host, port.to_i]
@@ -65,4 +66,4 @@ private
     @connections ||= {}
   end
 
-end
+end

data/lib/fastcache/bucket/modulus.rb

@@ -1,16 +1,14 @@
 class FastCache::ModulusBucket
 
-  def initialize(key, hash)
-    @digest = hash.new(key).hexdigest.to_i(16)
-    @key = key
+  def initialize(nodes)
+    @nodes = nodes
   end
 
-  def select(nodes)
-    count = nodes.size
-    # Note: An upper bound on tries ought to be given at some point
+  def select(hash)
+    count = @nodes.size
     count.times do |i|
       begin
-        break yield(@key, nodes[(@digest + i) % count])
+        break yield(@nodes[(hash + i) % count])
       rescue FastCache::Memcache::ProtocolError
         next
       end

data/lib/fastcache/interface/connection.rb

@@ -1,24 +1,19 @@
 class FastCache::Connection
   include FastCache::Memcache::Protocol
 
-  attr_accessor :bucket_class, :hash_class, :marshal_module
-  attr_reader :nodes
+  attr_accessor :router
 
-  def initialize(nodes, opts)
+  CONNECTION_OPTIONS = {
+    :router => FastCache::BasicRouter}
+
+  def initialize(nodes, opts = nil)
+    opts = CONNECTION_OPTIONS.merge(opts || {})
     @nodes = nodes.map {|(host, port)| FastCache::Memcache::Node.new(host, port)}
-    @bucket_class = FastCache::ModulusBucket
-    @hash_class = FastCache::CRC32
-    @marshal_module = Marshal # Ruby's built in marshal
+    @router = opts[:router].new(@nodes)
   end
 
-  def close
+  def close_all_connections
     @nodes.each do |node| node.close end
   end
 
-private
-
-  def bucket(key)
-    @bucket_class.new(key, @hash_class)
-  end
-
-end
+end

data/lib/fastcache/memcache.rb

@@ -1,8 +1,7 @@
 module FastCache; end
-module FastCache::Memcache
-  class ProtocolError < RuntimeError; end
-end
+module FastCache::Memcache; end
 
 # Memcache components
 require 'fastcache/memcache/node'
 require 'fastcache/memcache/protocol'
+require 'fastcache/memcache/errors'

data/lib/fastcache/memcache/errors.rb

@@ -0,0 +1,3 @@
+module FastCache::Memcache
+  class ProtocolError < RuntimeError; end
+end

data/lib/fastcache/memcache/node.rb

@@ -30,7 +30,7 @@ class FastCache::Memcache::Node
   end
 
   def close
-    socket.close
+    socket.close if @socket
     @socket = nil
   end
 
@@ -41,7 +41,7 @@ class FastCache::Memcache::Node
 private
 
   def socket
-    return @socket if @socket and not @socket.closed?
+    return @socket if @socket && !@socket.closed?
 
     @socket = nil
 

data/lib/fastcache/memcache/protocol.rb

@@ -1,11 +1,8 @@
-# Informal protocol for mixin:
-#  bucket will ask for a key and return a bucket
-#  nodes will return connection nodes
 module FastCache::Memcache::Protocol
 
   def get(key)
-    bucket(key).select(nodes) {|node_key, node|
-      node.write "get #{node_key}\r\n"
+    router.route(key) {|node|
+      node.write "get #{key}\r\n"
       resp = node.gets
       break FastCache::Maybe.nothing if resp == "END\r\n"
       resp =~ /(\d+)\r/
@@ -21,8 +18,8 @@ module FastCache::Memcache::Protocol
 
   def set(key, value, expiry = 0)
     value = value.to_s
-    bucket(key).select(nodes) {|node_key, node|
-      node.write "set #{node_key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
+    router.route(key) {|node|
+      node.write "set #{key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
       result = node.gets
       if result == "STORED\r\n"
         FastCache::Maybe.just(value)
@@ -36,8 +33,8 @@ module FastCache::Memcache::Protocol
 
   def add(key, value, expiry = 0)
     data = value.to_s
-    bucket(key).select(nodes) {|node_key, node|
-      node.write "add #{node_key} 0 #{expiry} #{data.size}\r\n#{data}\r\n"
+    router.route(key) {|node|
+      node.write "add #{key} 0 #{expiry} #{data.size}\r\n#{data}\r\n"
       resp = node.gets
       if resp == "STORED\r\n"
         FastCache::Maybe.just(data)
@@ -51,8 +48,8 @@ module FastCache::Memcache::Protocol
 
   def replace(key, value, expiry = 0)
     data = value.to_s
-    bucket(key).select(nodes) {|node_key, node|
-      node.write "replace #{node_key} 0 #{expiry} #{data.size}\r\n#{data}\r\n"
+    router.route(key) {|node|
+      node.write "replace #{key} 0 #{expiry} #{data.size}\r\n#{data}\r\n"
       resp = node.gets
       if resp == "STORED\r\n"
         FastCache::Maybe.just(data)
@@ -65,12 +62,12 @@ module FastCache::Memcache::Protocol
   end
 
   def delete(key, expiry = 0)
-    bucket(key).select(nodes) {|node_key, node|
-      node.write "delete #{node_key} #{expiry}\r\n"
+    router.route(key) {|node|
+      node.write "delete #{key} #{expiry}\r\n"
       resp = node.gets
       resp == "DELETED\r\n"
     }
-  rescue FastCache::Memcache::Protocol
+  rescue FastCache::Memcache::ProtocolError
     FastCache::Maybe.nothing
   end
 
@@ -78,20 +75,42 @@ module FastCache::Memcache::Protocol
     fail 'Not implemented'
   end
 
-  def incr(*)
-    fail 'Not implemented'
+  def incr(key, count)
+    router.route(key) {|node|
+      node.write "incr #{key} #{count}\r\n"
+      resp = node.gets
+      resp == "NOT_FOUND\r\n" ?
+        nil :
+        resp.to_i
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
   end
 
-  def decr(*)
-    fail 'Not implemented'
+  def decr(key, count)
+    router.route(key) {|node|
+      node.write "decr #{key} #{count}\r\n"
+      resp = node.gets
+      resp == "NOT_FOUND\r\n" ?
+        nil :
+        resp.to_i
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
   end
 
-  def flush_all_caches
-    fail 'Not implemented'
+  def flush_all_caches(delay = nil)
+    router.each {|node|
+      node.write "flush_all #{delay} noreply\r\n"
+    }
+    self
   end
 
-  def flush_cache(key)
-    fail 'Not implemented'
+  def flush_cache(key, delay = nil)
+    router.route(key) {|node|
+      node.write "flush_all #{delay} noreply\r\n"
+    }
+    self
   end
 
   def stats(*)
@@ -99,7 +118,7 @@ module FastCache::Memcache::Protocol
   end
 
   def reset_connections
-    fail 'Not implemented yet'
+    router.each {|node| node.close}
   end
 
 end

data/lib/fastcache/routing/basic_router.rb

@@ -0,0 +1,20 @@
+class FastCache::BasicRouter
+
+  attr_reader :bucket_delegate, :hash_delegate
+
+  def initialize(nodes, bucket_class = FastCache::ModulusBucket, hash_class = FastCache::CRC32)
+    @nodes = nodes
+    @bucket_delegate = bucket_class.new(nodes)
+    @hash_delegate = hash_class
+  end
+
+  def each(&b)
+    @nodes.each(&b)
+  end
+
+  def route(key, &b)
+    digest = @hash_delegate.new(key.to_s).digest
+    @bucket_delegate.select(digest.unpack('N').first, &b)
+  end
+
+end

data/lib/fastcache/util/maybe.rb

@@ -56,4 +56,4 @@ class FastCache::Maybe
   end
   alias clear! void
 
-end
+end

data/spec/routing/basic_router_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include FastCache
+
+describe BasicRouter, '.new' do
+
+  it 'should take a nodes list, bucket delegate, and hashing delegate' do
+    router = BasicRouter.new([], ModulusBucket, CRC32)
+    router.bucket_delegate.should be_kind_of(ModulusBucket)
+    router.hash_delegate.should == CRC32
+  end
+
+  it 'should default to modulus and crc32 based delegates' do
+    router = BasicRouter.new([])
+    router.bucket_delegate.should be_kind_of(ModulusBucket)
+    router.hash_delegate.should == CRC32
+  end
+
+end
+
+describe BasicRouter, '#route' do
+
+  before :each do
+    @nodes = [:one, :two, :three, :four]
+    @router = BasicRouter.new(@nodes)
+  end
+
+  it 'should route to the same buck if the string representation is the same' do
+    @router.route(:key) {|n| @n1 = n}
+    @router.route('key') {|n| @n2 = n}
+    @n1.should == @n2
+  end
+
+  it 'should return a node' do
+    @nodes.should include(@router.route('x') {|n| n})
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: binary42-fastcache
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Brian Mitchell
@@ -26,18 +26,19 @@ files:
 - lib/fastcache/hash/md5.rb
 - lib/fastcache/hash/crc32.rb
 - lib/fastcache/util/maybe.rb
+- lib/fastcache/routing/basic_router.rb
 - lib/fastcache/marshal/yaml.rb
 - lib/fastcache/marshal/duck.rb
 - lib/fastcache/marshal/ruby.rb
 - lib/fastcache/bucket/modulus.rb
 - lib/fastcache/bucket/consistent.rb
-- lib/fastcache/router/basic.rb
 - lib/fastcache/interface/dictionary.rb
 - lib/fastcache/interface/evaluator.rb
 - lib/fastcache/interface/connection.rb
 - lib/fastcache/memcache.rb
 - lib/fastcache/memcache/node.rb
 - lib/fastcache/memcache/protocol.rb
+- lib/fastcache/memcache/errors.rb
 - lib/fastcache.rb
 - LICENSE
 - Rakefile
@@ -73,9 +74,10 @@ specification_version: 2
 summary: FastCache - a client side implementation of the memcached protocol
 test_files: 
 - spec/util/maybe_spec.rb
+- spec/routing/basic_router_spec.rb
 - spec/spec_helper.rb
 - spec/memcache/node_spec.rb
 - spec/memcache/protocol_spec.rb
-- benchmark/connection.rb
 - benchmark/benchmark_helper.rb
+- benchmark/basic.rb
 - Rakefile

data/benchmark/connection.rb

@@ -1,15 +0,0 @@
-n = 1000
-Benchmark.bm(30) do |x|
-  x.report 'manual connection open/close' do
-    n.times do
-      conn = FastCache.connect NODE
-      conn.close
-    end
-  end
-
-  x.report 'block connection open/close' do
-    n.times do
-      FastCache.connect(NODE) {}
-    end
-  end
-end