remcached 0.3.1

data/lib/remcached/packet.rb

@@ -0,0 +1,275 @@
+require 'remcached/pack_array'
+
+module Memcached
+  class Packet
+    ##
+    # Initialize with fields
+    def initialize(contents={})
+      @contents = contents
+      (self.class.fields +
+       self.class.extras).each do |name,fmt,default|
+        self[name] ||= default if default
+      end
+    end
+
+    ##
+    # Get field
+    def [](field)
+      @contents[field]
+    end
+
+    ##
+    # Set field
+    def []=(field, value)
+      @contents[field] = value
+    end
+
+    ##
+    # Define a field for subclasses
+    def self.field(name, packed, default=nil)
+      instance_eval do
+        @fields ||= []
+        @fields << [name, packed, default]
+      end
+    end
+
+    ##
+    # Fields of parent and this class
+    def self.fields
+      parent_class = ancestors[1]
+      parent_fields = parent_class.respond_to?(:fields) ? parent_class.fields : []
+      class_fields = instance_eval { @fields || [] }
+      parent_fields + class_fields
+    end
+
+    ##
+    # Define an extra for subclasses
+    def self.extra(name, packed, default=nil)
+      instance_eval do
+        @extras ||= []
+        @extras << [name, packed, default]
+      end
+    end
+
+    ##
+    # Extras of this class
+    def self.extras
+      parent_class = ancestors[1]
+      parent_extras = parent_class.respond_to?(:extras) ? parent_class.extras : []
+      class_extras = instance_eval { @extras || [] }
+      parent_extras + class_extras
+    end
+
+    ##
+    # Build a packet by parsing header fields
+    def self.parse_header(buf)
+      pack_fmt = fields.collect { |name,fmt,default| fmt }.join
+      values = PackArray.unpack(buf, pack_fmt)
+
+      contents = {}
+      fields.each do |name,fmt,default|
+        contents[name] = values.shift
+      end
+
+      new contents
+    end
+
+    ##
+    # Parse body of packet when the +:total_body_length+ field is
+    # known by header. Pass it at least +total_body_length+ bytes.
+    #
+    # return:: [String] remaining bytes
+    def parse_body(buf)
+      buf, rest = buf[0..(self[:total_body_length] - 1)], buf[self[:total_body_length]..-1]
+
+      if self[:extras_length] > 0
+        self[:extras] = parse_extras(buf[0..(self[:extras_length]-1)])
+      else
+        self[:extras] = parse_extras("")
+      end
+      if self[:key_length] > 0
+        self[:key] = buf[self[:extras_length]..(self[:extras_length]+self[:key_length]-1)]
+      else
+        self[:key] = ""
+      end
+      self[:value] = buf[(self[:extras_length]+self[:key_length])..-1]
+
+      rest
+    end
+
+    ##
+    # Serialize for wire
+    def to_s
+      extras_s = extras_to_s
+      key_s = self[:key].to_s
+      value_s = self[:value].to_s
+      self[:extras_length] = extras_s.length
+      self[:key_length] = key_s.length
+      self[:total_body_length] = extras_s.length + key_s.length + value_s.length
+      header_to_s + extras_s + key_s + value_s
+    end
+
+    protected
+
+    def parse_extras(buf)
+      pack_fmt = self.class.extras.collect { |name,fmt,default| fmt }.join
+      values = PackArray.unpack(buf, pack_fmt)
+      self.class.extras.each do |name,fmt,default|
+        @self[name] = values.shift || default
+      end
+    end
+
+    def header_to_s
+      pack_fmt = ''
+      values = []
+      self.class.fields.each do |name,fmt,default|
+        values << self[name]
+        pack_fmt += fmt
+      end
+      PackArray.pack(values, pack_fmt)
+    end
+
+    def extras_to_s
+      values = []
+      pack_fmt = ''
+      self.class.extras.each do |name,fmt,default|
+        values << self[name] || default
+        pack_fmt += fmt
+      end
+
+      PackArray.pack(values, pack_fmt)
+    end
+  end
+
+  ##
+  # Request header:
+  #
+  #   Byte/     0       |       1       |       2       |       3       |
+  #      /              |               |               |               |
+  #     |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
+  #     +---------------+---------------+---------------+---------------+
+  #    0| Magic         | Opcode        | Key length                    |
+  #     +---------------+---------------+---------------+---------------+
+  #    4| Extras length | Data type     | Reserved                      |
+  #     +---------------+---------------+---------------+---------------+
+  #    8| Total body length                                             |
+  #     +---------------+---------------+---------------+---------------+
+  #   12| Opaque                                                        |
+  #     +---------------+---------------+---------------+---------------+
+  #   16| CAS                                                           |
+  #     |                                                               |
+  #     +---------------+---------------+---------------+---------------+
+  #     Total 24 bytes
+  class Request < Packet
+    field :magic, 'C', 0x80
+    field :opcode, 'C', 0
+    field :key_length, 'n'
+    field :extras_length, 'C'
+    field :data_type, 'C', 0
+    field :reserved, 'n', 0
+    field :total_body_length, 'N'
+    field :opaque, 'N', 0
+    field :cas, 'Q', 0
+
+    def self.parse_header(buf)
+      me = super
+      me[:magic] == 0x80 ? me : nil
+    end
+
+    class Get < Request
+      def initialize(contents)
+        super({:opcode=>Commands::GET}.merge(contents))
+      end
+
+      class Quiet < Get
+        def initialize(contents)
+          super({:opcode=>Commands::GETQ}.merge(contents))
+        end
+      end
+    end
+
+    class Add < Request
+      extra :flags, 'N', 0
+      extra :expiration, 'N', 0
+
+      def initialize(contents)
+        super({:opcode=>Commands::ADD}.merge(contents))
+      end
+
+      class Quiet < Add
+        def initialize(contents)
+          super({:opcode=>Commands::ADDQ}.merge(contents))
+        end
+      end
+    end
+
+    class Set < Request
+      extra :flags, 'N', 0
+      extra :expiration, 'N', 0
+
+      def initialize(contents)
+        super({:opcode=>Commands::SET}.merge(contents))
+      end
+
+      class Quiet < Set
+        def initialize(contents)
+          super({:opcode=>Commands::SETQ}.merge(contents))
+        end
+      end
+    end
+
+    class Delete < Request
+      def initialize(contents)
+        super({:opcode=>Commands::DELETE}.merge(contents))
+      end
+
+      class Quiet < Delete
+        def initialize(contents)
+          super({:opcode=>Commands::DELETEQ}.merge(contents))
+        end
+      end
+    end
+
+    class Stats < Request
+      def initialize(contents)
+        super({:opcode=>Commands::STAT}.merge(contents))
+      end
+    end
+  end
+
+  ##
+  # Response header:
+  #
+  #   Byte/     0       |       1       |       2       |       3       |
+  #      /              |               |               |               |
+  #     |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
+  #     +---------------+---------------+---------------+---------------+
+  #    0| Magic         | Opcode        | Key Length                    |
+  #     +---------------+---------------+---------------+---------------+
+  #    4| Extras length | Data type     | Status                        |
+  #     +---------------+---------------+---------------+---------------+
+  #    8| Total body length                                             |
+  #     +---------------+---------------+---------------+---------------+
+  #   12| Opaque                                                        |
+  #     +---------------+---------------+---------------+---------------+
+  #   16| CAS                                                           |
+  #     |                                                               |
+  #     +---------------+---------------+---------------+---------------+
+  #     Total 24 bytes
+  class Response < Packet
+    field :magic, 'C', 0x81
+    field :opcode, 'C', 0
+    field :key_length, 'n'
+    field :extras_length, 'C'
+    field :data_type, 'C', 0
+    field :status, 'n', Errors::NO_ERROR
+    field :total_body_length, 'N'
+    field :opaque, 'N', 0
+    field :cas, 'Q', 0
+
+    def self.parse_header(buf)
+      me = super
+      me[:magic] == 0x81 ? me : nil
+    end
+  end
+end

data/lib/remcached.rb

@@ -0,0 +1,158 @@
+require 'remcached/const'
+require 'remcached/packet'
+require 'remcached/client'
+
+module Memcached
+  class << self
+    ##
+    # +servers+: Array of host:port strings
+    def servers=(servers)
+      if defined?(@clients) && @clients
+        while client = @clients.shift
+          begin
+            client.close
+          rescue Exception
+            # This is allowed to fail silently
+          end
+        end
+      end
+
+      @clients = servers.collect { |server|
+        host, port = server.split(':')
+        Client.connect host, (port ? port.to_i : 11211)
+      }
+    end
+  
+    def usable?
+      usable_clients.length > 0
+    end
+
+    def usable_clients
+      unless defined?(@clients) && @clients
+        []
+      else
+        @clients.select { |client| client.connected? }
+      end
+    end
+
+    def client_for_key(key)
+      usable_clients_ = usable_clients
+      if usable_clients_.empty?
+        nil
+      else
+        h = hash_key(key) % usable_clients_.length
+        usable_clients_[h]
+      end
+    end
+
+    def hash_key(key)
+      hashed = 0
+      i = 0
+      key.each_byte do |b|
+        j = key.length - i - 1 % 4
+        hashed ^= b << (j * 8)
+        i += 1
+      end
+      hashed
+    end
+
+
+    ##
+    # Memcached operations
+    ##
+
+    def operation(request_klass, contents, &callback)
+      client = client_for_key(contents[:key])
+      if client
+        client.send_request request_klass.new(contents), &callback
+      elsif callback
+        callback.call :status => Errors::DISCONNECTED
+      end
+    end
+
+    def add(contents, &callback)
+      operation Request::Add, contents, &callback
+    end
+    def get(contents, &callback)
+      operation Request::Get, contents, &callback
+    end
+    def set(contents, &callback)
+      operation Request::Set, contents, &callback
+    end
+    def delete(contents, &callback)
+      operation Request::Delete, contents, &callback
+    end
+
+
+    ##
+    # Multi operations
+    #
+    ##
+
+    def multi_operation(request_klass, contents_list, &callback)
+      if contents_list.empty?
+        callback.call []
+        return self
+      end
+
+      results = {}
+
+      # Assemble client connections per keys
+      client_contents = {}
+      contents_list.each do |contents|
+        client = client_for_key(contents[:key])
+        if client
+          client_contents[client] ||= []
+          client_contents[client] << contents
+        else
+          puts "no client for #{contents[:key].inspect}"
+          results[contents[:key]] = {:status => Memcached::Errors::DISCONNECTED}
+        end
+      end
+
+      # send requests and wait for responses per client
+      clients_pending = client_contents.length
+      client_contents.each do |client,contents_list|
+        last_i = contents_list.length - 1
+        client_results = {}
+
+        contents_list.each_with_index do |contents,i|
+          if i < last_i
+            request = request_klass::Quiet.new(contents)
+            client.send_request(request) { |response|
+              results[contents[:key]] = response
+            }
+          else # last request for this client
+            request = request_klass.new(contents)
+            client.send_request(request) { |response|
+              results[contents[:key]] = response
+              clients_pending -= 1
+              if clients_pending < 1
+                callback.call results
+              end
+            }
+          end
+        end
+      end
+
+      self
+    end
+
+    def multi_add(contents_list, &callback)
+      multi_operation Request::Add, contents_list, &callback
+    end
+
+    def multi_get(contents_list, &callback)
+      multi_operation Request::Get, contents_list, &callback
+    end
+
+    def multi_set(contents_list, &callback)
+      multi_operation Request::Set, contents_list, &callback
+    end
+
+    def multi_delete(contents_list, &callback)
+      multi_operation Request::Delete, contents_list, &callback
+    end
+
+  end
+end

data/remcached.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remcached}
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stephan Maka"]
+  s.date = %q{2009-10-12}
+  s.description = %q{Ruby EventMachine memcached client}
+  s.email = %q{astro@spaceboyz.net}
+  s.extra_rdoc_files = [
+    "README.rst"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.rst",
+     "Rakefile",
+     "VERSION.yml",
+     "examples/fill.rb",
+     "lib/remcached.rb",
+     "lib/remcached/client.rb",
+     "lib/remcached/const.rb",
+     "lib/remcached/pack_array.rb",
+     "lib/remcached/packet.rb",
+     "remcached.gemspec",
+     "spec/client_spec.rb",
+     "spec/memcached_spec.rb",
+     "spec/packet_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/astro/remcached/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ruby EventMachine memcached client}
+  s.test_files = [
+    "spec/client_spec.rb",
+     "spec/memcached_spec.rb",
+     "spec/packet_spec.rb",
+     "examples/fill.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,36 @@
+$: << File.dirname(__FILE__) + '/../lib'
+require 'remcached'
+
+describe Memcached::Client do
+
+  def run(&block)
+    EM.run do
+      @cl = Memcached::Client.connect('localhost', &block)
+    end
+  end
+  def stop
+    @cl.close_connection
+    EM.stop
+  end
+
+
+  context "when getting stats" do
+    before :all do
+      @stats = {}
+      run do
+        @cl.stats do |result|
+          result[:status].should == Memcached::Errors::NO_ERROR
+          if result[:key] != ''
+            @stats[result[:key]] = result[:value]
+          else
+            stop
+          end
+        end
+      end
+    end
+
+    it "should have received some keys" do
+      @stats.should include(*%w(pid uptime time version curr_connections total_connections))
+    end
+  end
+end