binary42-fastcache 0.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Upswing CRM, LLC
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,4 @@
+FastCache
+=========
+
+FastCache is a simple client library implementing the memcache protocol. It currently aims to support all documented commands and features in version 1.2.6. Secondary goals include support for a modular serialization and node selection system as well as some convenient utility classes for wrapping memcached clusters.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc 'Run specs'
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Rake::RDocTask.new do |task|
+  task.rdoc_dir = 'doc'
+  task.title = 'FastCache - memcache client protocol implementation'
+  task.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  task.rdoc_files.include 'README'
+  task.rdoc_files.include 'lib/**/*.rb'
+end

data/benchmark/benchmark_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'benchmark'
+require 'fastcache'
+
+NODE = ENV['NODE'] || 'localhost:11211'

data/benchmark/connection.rb

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

data/lib/fastcache/bucket/consistent.rb

@@ -0,0 +1,3 @@
+class FastCache::ConsistentBucket
+  # TODO: Implement a basic Ruby consistent hasher
+end

data/lib/fastcache/bucket/modulus.rb

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

data/lib/fastcache/hash/crc32.rb

@@ -0,0 +1,30 @@
+class FastCache::CRC32
+
+  def initialize(string = nil)
+    @crc = 0xFFFFFFFF
+    self << string if string
+  end
+
+  def <<(string)
+    string.size.times do |i|
+      @crc ^= string[i]
+      8.times do
+        if (@crc & 1).zero?
+          @crc >>= 1
+        else
+          @crc = (@crc >> 1) ^ 0xEDB88320
+        end
+      end
+    end
+    self
+  end
+
+  def digest
+    [@crc ^ 0xFFFFFFFF].pack('N')
+  end
+
+  def hexdigest
+    (@crc ^ 0xFFFFFFFF).to_s(16)
+  end
+
+end

data/lib/fastcache/hash/md5.rb

@@ -0,0 +1,3 @@
+require 'openssl'
+
+FastCache::MD5 = OpenSSL::Digest::MD5

data/lib/fastcache/hash/sha1.rb

@@ -0,0 +1,3 @@
+require 'openssl'
+
+FastCache::SHA1 = OpenSSL::Digest::SHA1

data/lib/fastcache/interface/connection.rb

@@ -0,0 +1,24 @@
+class FastCache::Connection
+  include FastCache::Memcache::Protocol
+
+  attr_accessor :bucket_class, :hash_class, :marshal_module
+  attr_reader :nodes
+
+  def initialize(nodes, 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
+  end
+
+  def close
+    @nodes.each do |node| node.close end
+  end
+
+private
+
+  def bucket(key)
+    @bucket_class.new(key, @hash_class)
+  end
+
+end

data/lib/fastcache/interface/dictionary.rb

@@ -0,0 +1,3 @@
+class FastCache::Dictionary < FastCache::Connection
+
+end

data/lib/fastcache/interface/evaluator.rb

@@ -0,0 +1,3 @@
+class FastCache::Evaluator < FastCache::Connection
+
+end

data/lib/fastcache/memcache/node.rb

@@ -0,0 +1,70 @@
+require 'socket'
+require 'timeout'
+
+class FastCache::Memcache::Node
+  attr_reader :host, :port, :status
+  attr_accessor :weight
+
+  CONNECT_TIMEOUT = 0.25
+  RETRY_DELAY = 10.0
+
+  def initialize(host, port)
+    @host = host
+    @port = port
+    @weight = 1
+    @status = :disconnected
+    @socket = nil
+    @retry = nil
+  end
+
+  def read(*a)
+    socket.read(*a)
+  end
+
+  def write(data)
+    socket.write(data)
+  end
+
+  def gets
+    socket.gets
+  end
+
+  def close
+    socket.close
+    @socket = nil
+  end
+
+  def connect
+    socket
+  end
+
+private
+
+  def socket
+    return @socket if @socket and not @socket.closed?
+
+    @socket = nil
+
+    # If the host was dead, don't retry for a while.
+    return if @retry and @retry > Time.now
+
+    # Attempt to connect if not already connected.
+    begin
+      @socket = timeout CONNECT_TIMEOUT do
+        TCPSocket.new @host, @port
+      end
+      @retry  = nil
+      @status = :connected
+    rescue SocketError, SystemCallError, IOError, Timeout::Error => err
+      @status = :dead
+      @socket = nil
+      @retry  = Time.now + RETRY_DELAY
+    end
+
+    @socket
+  rescue IOError
+    @socket = nil
+    retry
+  end
+
+end

data/lib/fastcache/memcache/protocol.rb

@@ -0,0 +1,105 @@
+# 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"
+      resp = node.gets
+      break FastCache::Maybe.nothing if resp == "END\r\n"
+      resp =~ /(\d+)\r/
+      value = node.read $1.to_i
+      node.read 2 # \r\n
+      node.gets # END\r\n
+      break FastCache::Maybe.just(value) unless value.nil?
+      FastCache::Maybe.nothing
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
+  end
+
+  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"
+      result = node.gets
+      if result == "STORED\r\n"
+        FastCache::Maybe.just(value)
+      else
+        FastCache::Maybe.nothing
+      end
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
+  end
+
+  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"
+      resp = node.gets
+      if resp == "STORED\r\n"
+        FastCache::Maybe.just(data)
+      else
+        FastCache::Maybe.nothing
+      end
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
+  end
+
+  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"
+      resp = node.gets
+      if resp == "STORED\r\n"
+        FastCache::Maybe.just(data)
+      else
+        FastCache::Maybe.nothing
+      end
+    }
+  rescue FastCache::Memcache::ProtocolError
+    FastCache::Maybe.nothing
+  end
+
+  def delete(key, expiry = 0)
+    bucket(key).select(nodes) {|node_key, node|
+      node.write "delete #{node_key} #{expiry}\r\n"
+      resp = node.gets
+      resp == "DELETED\r\n"
+    }
+  rescue FastCache::Memcache::Protocol
+    FastCache::Maybe.nothing
+  end
+
+  def cas(*)
+    fail 'Not implemented'
+  end
+
+  def incr(*)
+    fail 'Not implemented'
+  end
+
+  def decr(*)
+    fail 'Not implemented'
+  end
+
+  def flush_all_caches
+    fail 'Not implemented'
+  end
+
+  def flush_cache(key)
+    fail 'Not implemented'
+  end
+
+  def stats(*)
+    fail 'Not implemented'
+  end
+
+  def reset_connections
+    fail 'Not implemented yet'
+  end
+
+end

data/lib/fastcache/memcache.rb

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

data/lib/fastcache/util/maybe.rb

@@ -0,0 +1,59 @@
+class FastCache::Maybe
+
+  def self.nothing
+    self.new
+  end
+
+  def self.just(x)
+    self.new(x)
+  end
+
+  def initialize(*args)
+    args.size < 2 or raise ArgumentError,
+      "#{self.class.name}#initialize only takes 0 or 1 arguments. Given #{args.size}."
+    if args.empty?
+      @value = nil
+      @nothing = true
+    else
+      @value = *args
+      @nothing = false
+    end
+  end
+
+  def anything?
+    !@nothing
+  end
+
+  def join(other)
+    (other.nothing? || self.nothing?) ?
+      Maybe.nothing :
+      other
+  end
+
+  def nothing?
+    @nothing
+  end
+  alias empty? nothing?
+  alias blank? nothing?
+
+  def value
+    if anything?
+      @value
+    else
+      raise 'No value set'
+    end
+  end
+
+  def value=(obj)
+    @nothing = false
+    @value = obj
+  end
+
+  def void
+    @nothing = true
+    @value = nil
+    self
+  end
+  alias clear! void
+
+end

data/lib/fastcache.rb

@@ -0,0 +1,68 @@
+module FastCache; end
+
+# Utilities and support
+require 'fastcache/util/maybe'
+
+# Bucketing algorithms
+require 'fastcache/bucket/consistent'
+require 'fastcache/bucket/modulus'
+
+# Key hashing algorithms
+require 'fastcache/hash/crc32'
+require 'fastcache/hash/md5'
+require 'fastcache/hash/sha1'
+
+# Key routers
+# TODO: Check for ruby-ketama
+require 'fastcache/router/basic'
+
+# Networking and protocol support code
+require 'fastcache/memcache'
+
+# Interfaces
+require 'fastcache/interface/connection'
+require 'fastcache/interface/dictionary'
+require 'fastcache/interface/evaluator'
+
+class << FastCache
+
+  def connect(node_list = 'localhost:11211', opts = {})
+    opts = {
+      :name => 'default',
+      :type => 'raw'
+    }.merge(opts)
+
+    connections[opts[:name]].close if connections[opts[:name]]
+
+    nodes = node_list.split(',').map {|node|
+      host, port = *node.split(':')
+      port ||= 80
+      [host, port.to_i]
+    }
+
+    connections[opts[:name]] = case(opts[:type])
+    when FastCache::Connection
+      opts[:type].new(nodes, opts[:connection])
+    when 'dictionary'
+      FastCache::Dictionary.new(nodes, opts[:connection])
+    when 'evaluator'
+      FastCache::Evaluator.new(nodes, opts[:connection])
+    when 'raw'
+      FastCache::Connection.new(nodes, opts[:connection])
+    else
+      raise "Unknown connection type #{opts[:type]}"
+    end
+  end
+
+  def connection(name = 'default')
+    connections[name] or raise ArgumentError,
+      "Invalid connection name #{name.inspect}"
+  end
+
+private
+
+  def connections
+    @connections ||= {}
+  end
+
+end

data/spec/memcache/node_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe FastCache::Memcache::Node, 'initialize' do
+
+  before :each do
+    @node = FastCache::Memcache::Node.new('localhost', 11211)
+  end
+
+  it 'should take host and port as arguments' do
+    @node.host.should == 'localhost'
+    @node.port.should == 11211
+  end
+
+  it 'should set a default weight of 1' do
+    @node.weight.should == 1
+  end
+
+  it 'should set a default status of disconnected' do
+    @node.status.should == :disconnected
+  end
+
+end
+
+describe FastCache::Memcache::Node, 'connect' do
+
+  before :each do
+    @conn = FastCache::Memcache::Node.new('localhost', 11211)
+  end
+
+  describe '(success)' do
+    it 'should set the status to :connected' do
+      TCPSocket.should_receive(:new).with(@conn.host, @conn.port)
+      @conn.connect
+      @conn.status.should == :connected
+    end
+  end
+
+  describe '(failure)' do
+    it 'should set the status to :dead' do
+      TCPSocket.should_receive(:new).with(@conn.host, @conn.port).and_raise(Errno::ECONNREFUSED)
+      @conn.connect
+      @conn.status.should == :dead
+    end
+  end
+
+end

data/spec/memcache/protocol_spec.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../spec_helper'

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'spec'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'fastcache'

data/spec/util/maybe_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include FastCache
+
+describe Maybe, '.nothing' do
+
+  it 'should return an object with nothing' do
+    Maybe.nothing.should be_nothing
+  end
+
+end
+
+describe Maybe, '.just' do
+
+  it 'should return an object with the passed value' do
+    Maybe.just(42).value.should == 42
+  end
+
+end
+
+describe Maybe, '#anything?' do
+
+  it 'should return true if there is a value' do
+    Maybe.just(42).should be_anything
+    Maybe.just(nil).should be_anything
+  end
+
+  it 'should return false if there is no value' do
+    Maybe.nothing.should_not be_anything
+  end
+
+end
+
+describe Maybe, '#nothing?' do
+
+  it 'should return false if there is a value' do
+    Maybe.just(42).should_not be_nothing
+    Maybe.just(nil).should_not be_nothing
+  end
+
+  it 'should return true if there is no value' do
+    Maybe.nothing.should be_nothing
+  end
+
+end
+
+describe Maybe, 'getting and setting wrapped values' do
+
+  it 'should allow setting a value on nothing' do
+    [:hello, nil, false, true].each do |val|
+      what = Maybe.nothing
+      what.value = val
+      what.should be_anything
+    end
+  end
+
+  it 'should should replace existing values' do
+    [:hello, nil, false, true].each do |val|
+      what = Maybe.just(42)
+      what.value = val
+      what.value.should == val
+    end
+  end
+
+end
+
+describe Maybe, '#join' do
+
+  it 'should keep nothing if nothing' do
+    Maybe.nothing.join(Maybe.nothing).should be_nothing
+    Maybe.nothing.join(Maybe.just(42)).should be_nothing
+  end
+
+  it 'should keep the new anything if anything' do
+    what = Maybe.just(42).join(Maybe.just(43))
+    what.should be_anything
+    what.value.should == 43
+  end
+
+  it 'should become nothing if anything is passed nothing' do
+    Maybe.just(42).join(Maybe.nothing).should be_nothing
+  end
+
+end
+
+describe Maybe, '#void' do
+
+  it 'should make an object with anything into one with nothing' do
+    Maybe.just(42).void.should be_nothing
+  end
+
+  it 'should not let nothing remain nothing' do
+    Maybe.nothing.void.should be_nothing
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: binary42-fastcache
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Brian Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: FastCache implements a flexible client side implementation of the memcached protocol. The library comes with a light core as well as some components to wrap the protocol with more advanced behaviors.
+email: brian.mitchell@excoventures.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/fastcache/hash/sha1.rb
+- lib/fastcache/hash/md5.rb
+- lib/fastcache/hash/crc32.rb
+- lib/fastcache/util/maybe.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.rb
+- LICENSE
+- Rakefile
+- README
+has_rdoc: true
+homepage: http://github.com/binary42/fastcache
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: FastCache - a client side implementation of the memcached protocol
+test_files: 
+- spec/util/maybe_spec.rb
+- spec/spec_helper.rb
+- spec/memcache/node_spec.rb
+- spec/memcache/protocol_spec.rb
+- benchmark/connection.rb
+- benchmark/benchmark_helper.rb
+- Rakefile