astro-remcached 0.2.0

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "remcached"
+    gemspec.summary = "Ruby EventMachine memcached client"
+    gemspec.description = gemspec.summary
+    gemspec.email = "astro@spaceboyz.net"
+    gemspec.homepage = "http://github.com/astro/remcached/"
+    gemspec.authors = ["Stephan Maka"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 2
+:patch: 0

data/lib/remcached/client.rb

@@ -0,0 +1,160 @@
+require 'eventmachine'
+
+module Memcached
+  class Connection < EventMachine::Connection
+    def self.connect(host, port=11211, &connect_callback)
+      df = EventMachine::DefaultDeferrable.new
+      df.callback &connect_callback
+
+      EventMachine.connect(host, port, self) do |me|
+        me.instance_eval { 
+          @host, @port = host, port
+          @connect_deferrable = df
+        }
+      end
+    end
+
+    def connected?
+      @connected
+    end
+
+    def reconnect
+      @connect_deferrable = EventMachine::DefaultDeferrable.new
+      super @host, @port
+      @connect_deferrable
+    end
+
+    def close
+      close_connection
+      @connected = false
+      @pending.each do |opaque, callback|
+        callback.call :status => Errors::DISCONNECTED
+      end
+    end
+
+    def post_init
+      @recv_buf = ""
+      @recv_state = :header
+      @connected = false
+    end
+
+    def connection_completed
+      @connected = true
+      @connect_deferrable.succeed(self)
+    end
+
+    RECONNECT_DELAY = 10
+    RECONNECT_JITTER = 5
+    def unbind
+      close
+      EventMachine::Timer.new(RECONNECT_DELAY + rand(RECONNECT_JITTER),
+                              method(:reconnect))
+    end
+
+    def send_packet(pkt)
+      send_data pkt.to_s
+    end
+
+    def receive_data(data)
+      @recv_buf += data
+
+      done = false
+      while not done
+
+        if @recv_state == :header && @recv_buf.length >= 24
+          @received = Response.parse_header(@recv_buf[0..23])
+          @recv_buf = @recv_buf[24..-1]
+          @recv_state = :body
+
+        elsif @recv_state == :body && @recv_buf.length >= @received[:total_body_length]
+          @recv_buf = @received.parse_body(@recv_buf)
+          receive_packet(@received)
+
+          @recv_state = :header
+
+        else
+          done = true
+        end
+      end
+    end
+  end
+
+  class Client < Connection
+    def post_init
+      super
+      @opaque_counter = 0
+      @pending = []
+    end
+
+    def send_request(pkt, &callback)
+      @opaque_counter += 1
+      @opaque_counter %= 1 << 32
+      pkt[:opaque] = @opaque_counter
+      send_packet pkt
+
+      if callback
+        @pending << [@opaque_counter, callback]
+      end
+    end
+
+    ##
+    # memcached responses possess the same order as their
+    # corresponding requests. Therefore quiet requests that have not
+    # yielded responses will be dropped silently to free memory from
+    # +@pending+
+    #
+    # When a callback has been fired and returned +:proceed+ without a
+    # succeeding packet, we still keep it referenced around for
+    # commands such as STAT which has multiple response packets.
+    def receive_packet(response)
+      pending_pos = nil
+      pending_callback = nil
+      @pending.each_with_index do |(pending_opaque,pending_cb),i|
+        if response[:opaque] == pending_opaque
+          pending_pos = i
+          pending_callback = pending_cb
+          break
+        end
+      end
+
+      if pending_pos
+        @pending = @pending[pending_pos..-1]
+        begin
+          if pending_callback.call(response) != :proceed
+            @pending.shift
+          end
+        rescue Exception => e
+          $stderr.puts "#{e.class}: #{e}\n" + e.backtrace.join("\n")
+        end
+      end
+    end
+
+
+    def get(contents, &callback)
+      send_request Request::Get.new(contents), &callback
+    end
+
+    def add(contents, &callback)
+      send_request Request::Add.new(contents), &callback
+    end
+
+    def set(contents, &callback)
+      send_request Request::Set.new(contents), &callback
+    end
+
+    def delete(contents, &callback)
+      send_request Request::Delete.new(contents), &callback
+    end
+
+    # Callback will be called multiple times
+    def stats(contents={}, &callback)
+      send_request Request::Stats.new(contents) do |result|
+        callback.call result
+
+        if result[:status] == Errors::NO_ERROR && result[:key] != ''
+          :proceed
+        end
+      end
+    end
+  end
+end

data/lib/remcached/const.rb

@@ -0,0 +1,60 @@
+module Memcached
+  module Datatypes
+    RAW_BYTES = 0x00
+  end
+
+  module Errors
+    NO_ERROR = 0x0000
+    KEY_NOT_FOUND = 0x0001
+    KEY_EXISTS = 0x0002
+    VALUE_TOO_LARGE = 0x0003
+    INVALID_ARGS = 0x0004
+    ITEM_NOT_STORED = 0x0005
+    NON_NUMERIC_VALUE = 0x0006
+
+    DISCONNECTED = 0xffff
+  end
+
+  module Commands
+    GET = 0x00
+    SET = 0x01
+    ADD = 0x02
+    REPLACE = 0x03
+    DELETE = 0x04
+    INCREMENT = 0x05
+    DECREMENT = 0x06
+    QUIT = 0x07
+    STAT = 0x10
+
+=begin
+   Possible values of the one-byte field:
+   0x00    Get
+   0x01    Set
+   0x02    Add
+   0x03    Replace
+   0x04    Delete
+   0x05    Increment
+   0x06    Decrement
+   0x07    Quit
+   0x08    Flush
+   0x09    GetQ
+   0x0A    No-op
+   0x0B    Version
+   0x0C    GetK
+   0x0D    GetKQ
+   0x0E    Append
+   0x0F    Prepend
+   0x10    Stat
+   0x11    SetQ
+   0x12    AddQ
+   0x13    ReplaceQ
+   0x14    DeleteQ
+   0x15    IncrementQ
+   0x16    DecrementQ
+   0x17    QuitQ
+   0x18    FlushQ
+   0x19    AppendQ
+   0x1A    PrependQ
+=end
+  end
+end

data/lib/remcached/pack_array.rb

@@ -0,0 +1,46 @@
+##
+# Works exactly like Array#pack and String#unpack, except that it
+# inverts 'q' & 'Q' prior packing/after unpacking. This is done to
+# achieve network byte order for these values on a little-endian machine.
+#
+# FIXME: implement check for big-endian machines.
+module Memcached::PackArray
+  def self.pack(ary, fmt1)
+    fmt2 = ''
+    values = []
+    fmt1.each_char do |c|
+      if c == 'Q' || c == 'q'
+        fmt2 += 'a8'
+        values << [ary.shift].pack(c).reverse
+      else
+        fmt2 += c
+        values << ary.shift
+      end
+    end
+
+    values.pack(fmt2)
+  end
+
+  def self.unpack(buf, fmt1)
+    fmt2 = ''
+    reverse = []
+    i = 0
+    fmt1.each_char do |c|
+      if c == 'Q' || c == 'q'
+        fmt2 += 'a8'
+        reverse << [i, c]
+      else
+        fmt2 += c
+      end
+      i += 1
+    end
+
+    ary = buf.unpack(fmt2)
+
+    reverse.each do |i, c|
+      ary[i], = ary[i].reverse.unpack(c)
+    end
+
+    ary
+  end
+end

data/lib/remcached/packet.rb

@@ -0,0 +1,227 @@
+require 'remcached/pack_array'
+
+module Memcached
+  class Packet
+    def initialize(contents={})
+      @contents = contents
+      (self.class.fields +
+       self.class.extras).each do |name,fmt,default|
+        self[name] ||= default if default
+      end
+    end
+
+    def [](field)
+      @contents[field]
+    end
+
+    def []=(field, value)
+      @contents[field] = value
+    end
+
+    # Define fields for subclasses
+    def self.field(name, packed, default=nil)
+      instance_eval do
+        @fields ||= []
+        @fields << [name, packed, default]
+      end
+    end
+
+    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
+
+    def self.extra(name, packed, default=nil)
+      instance_eval do
+        @extras ||= []
+        @extras << [name, packed, default]
+      end
+    end
+
+    def self.extras
+      instance_eval { @extras || [] }
+    end
+
+    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
+
+    # Return 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
+
+    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(contents.merge :opcode=>Commands::GET)
+      end
+    end
+
+    class Add < Request
+      extra :flags, 'N', 0
+      extra :expiration, 'N', 0
+
+      def initialize(contents)
+        super(contents.merge :opcode=>Commands::ADD)
+      end
+    end
+
+    class Set < Request
+      extra :flags, 'N', 0
+      extra :expiration, 'N', 0
+
+      def initialize(contents)
+        super(contents.merge :opcode=>Commands::SET)
+      end
+    end
+
+    class Delete < Request
+      def initialize(contents)
+        super(contents.merge :opcode=>Commands::DELETE)
+      end
+    end
+
+    class Stats < Request
+      def initialize(contents)
+        super(contents.merge :opcode=>Commands::STAT)
+      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,81 @@
+require 'remcached/const'
+require 'remcached/packet'
+require 'remcached/client'
+
+module Memcached
+  class << self
+    ##
+    # +servers+: either Array of host:port strings or Hash of
+    # host:port => weight integers
+    def servers=(servers)
+      if defined?(@clients) && @clients
+        while client = @clients.shift
+          client.close
+        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
+      key.bytes.each_with_index do |b, i|
+        j = key.length - i - 1 % 4
+        hashed ^= b << (j * 8)
+      end
+      hashed
+    end
+
+    def operation(op, contents, &callback)
+      client = client_for_key(contents[:key])
+      if client
+        client.send(op, contents, &callback)
+      elsif callback
+        callback.call :status => Errors::DISCONNECTED
+      end
+    end
+
+
+    ##
+    # Memcached operations
+    ##
+
+    def add(contents, &callback)
+      operation :add, contents, &callback
+    end
+    def get(contents, &callback)
+      operation :get, contents, &callback
+    end
+    def set(contents, &callback)
+      operation :set, contents, &callback
+    end
+    def delete(contents, &callback)
+      operation :delete, contents, &callback
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,151 @@
+$: << 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
+    EM.stop
+  end
+
+
+  it "should add a value" do
+    run do
+      @cl.add(:key => 'Hello',
+              :value => 'World') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::NO_ERROR
+        result[:cas].should_not == 0
+        stop
+      end
+    end
+  end
+
+  it "should get a value" do
+    run do
+      @cl.get(:key => 'Hello') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::NO_ERROR
+        result[:value].should == 'World'
+        result[:cas].should_not == 0
+        @old_cas = result[:cas]
+        stop
+      end
+    end
+  end
+
+  it "should set a value" do
+    run do
+      @cl.set(:key => 'Hello',
+              :value => 'Planet') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::NO_ERROR
+        result[:cas].should_not == 0
+        result[:cas].should_not == @old_cas
+        stop
+      end
+    end
+  end
+
+  it "should get a value" do
+    run do
+      @cl.get(:key => 'Hello') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::NO_ERROR
+        result[:value].should == 'Planet'
+        result[:cas].should_not == @old_cas
+        stop
+      end
+    end
+  end
+
+  it "should delete a value" do
+    run do
+      @cl.delete(:key => 'Hello') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::NO_ERROR
+        stop
+      end
+    end
+  end
+
+  it "should not get a value" do
+    run do
+      @cl.get(:key => 'Hello') do |result|
+        result.should be_kind_of(Memcached::Response)
+        result[:status].should == Memcached::Errors::KEY_NOT_FOUND
+        stop
+      end
+    end
+  end
+
+  $n = 100
+  context "when incrementing a counter #{$n} times" do
+    it "should initialize the counter" do
+      run do
+        @cl.set(:key => 'counter',
+                :value => '0') do |result|
+          stop
+        end
+      end
+    end
+
+    it "should count #{$n} times" do
+      $counted = 0
+      def count
+        @cl.get(:key => 'counter') do |result|
+          result[:status].should == Memcached::Errors::NO_ERROR
+          value = result[:value].to_i
+          @cl.set(:key => 'counter',
+                  :value => (value + 1).to_s,
+                  :cas => result[:cas]) do |result|
+            if result[:status] == Memcached::Errors::KEY_EXISTS
+              count # again
+            else
+              result[:status].should == Memcached::Errors::NO_ERROR
+              $counted += 1
+              stop if $counted >= $n
+            end
+          end
+        end
+      end
+      run do
+        $n.times { count }
+      end
+    end
+
+    it "should have counted up to #{$n}" do
+      run do
+        @cl.get(:key => 'counter') do |result|
+          result[:status].should == Memcached::Errors::NO_ERROR
+          result[:value].to_i.should == $n
+          stop
+        end
+      end
+    end
+  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

data/spec/memcached_spec.rb

@@ -0,0 +1,58 @@
+$: << File.dirname(__FILE__) + '/../lib'
+require 'remcached'
+
+describe Memcached::Client do
+  def run(&block)
+    EM.run do
+      Memcached.servers = %w(127.0.0.2 localhost:11212 localhost localhost)
+
+      started = false
+      EM::PeriodicTimer.new(0.1) do
+        if !started && Memcached.usable?
+          started = true
+          block.call
+        end
+      end
+
+    end
+  end
+  def stop
+    EM.stop
+  end
+
+  context "when using multiple servers" do
+    it "should not return the same hash for the succeeding key" do
+      run do
+        Memcached.hash_key('0').should_not == Memcached.hash_key('1')
+        stop
+      end
+    end
+
+    it "should not return the same client for the succeeding key" do
+      run do
+        # wait for 2nd client to be connected
+        EM::Timer.new(0.1) do
+          Memcached.client_for_key('0').should_not == Memcached.client_for_key('1')
+          stop
+        end
+      end
+    end
+
+    it "should spread load (observe from outside :-)" do
+      run do
+
+        n = 10000
+        replies = 0
+        n.times do |i|
+          Memcached.set(:key => "#{i % 100}",
+                        :value => rand(1 << 31).to_s) {
+            replies += 1
+            stop if replies >= n
+          }
+        end
+      end
+
+    end
+  end
+
+end

data/spec/packet_spec.rb

@@ -0,0 +1,125 @@
+$: << File.dirname(__FILE__) + '/../lib'
+require 'remcached'
+
+describe Memcached::Packet do
+
+  context "when generating a request" do
+    it "should set default values" do
+      pkt = Memcached::Request.new
+      pkt[:magic].should == 0x80
+    end
+
+    context "example 4.2.1" do
+      before :all do
+        pkt = Memcached::Request.new(:key => 'Hello')
+        @s = pkt.to_s
+      end
+
+      it "should serialize correctly" do
+        @s.should == "\x80\x00\x00\x05" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x05" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00" +
+          "Hello"
+      end
+    end
+
+    context "example 4.3.1 (add)" do
+      before :all do
+        pkt = Memcached::Request::Add.new(:flags => 0xdeadbeef,
+                                          :expiration => 0xe10,
+                                          :key => "Hello",
+                                          :value => "World")
+        @s = pkt.to_s
+      end
+
+      it "should serialize correctly" do
+        @s.should == "\x80\x02\x00\x05" +
+          "\x08\x00\x00\x00" +
+          "\x00\x00\x00\x12" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00" +
+          "\xde\xad\xbe\xef" +
+          "\x00\x00\x0e\x10" +
+          "Hello" +
+          "World"
+      end
+    end
+  end
+
+  context "when parsing a response" do
+    context "example 4.1.1" do
+      before :all do
+        s = "\x81\x00\x00\x00\x00\x00\x00\x01" +
+          "\x00\x00\x00\x09\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00\x00\x00\x00\x00" +
+          "Not found"
+        @pkt = Memcached::Response.parse_header(s[0..23])
+        @pkt.parse_body(s[24..-1])
+      end
+
+      it "should return the right class according to magic & opcode" do
+        @pkt[:magic].should == 0x81
+        @pkt[:opcode].should == 0
+        @pkt.class.should == Memcached::Response
+      end
+      it "should return the right data type" do
+        @pkt[:data_type].should == 0
+      end
+      it "should return the right status" do
+        @pkt[:status].should == Memcached::Errors::KEY_NOT_FOUND
+      end
+      it "should return the right opaque" do
+        @pkt[:opaque].should == 0
+      end
+      it "should return the right CAS" do
+        @pkt[:cas].should == 0
+      end
+      it "should parse the body correctly" do
+        @pkt[:extras].should be_empty
+        @pkt[:key].should == ""
+        @pkt[:value].should == "Not found"
+      end
+    end
+
+    context "example 4.2.1" do
+      before :all do
+        s =  "\x81\x00\x00\x00" +
+          "\x04\x00\x00\x00" +
+          "\x00\x00\x00\x09" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x00" +
+          "\x00\x00\x00\x01" +
+          "\xde\xad\xbe\xef" +
+          "World"
+        @pkt = Memcached::Response.parse_header(s[0..23])
+        @pkt.parse_body(s[24..-1])
+      end
+
+      it "should return the right class according to magic & opcode" do
+        @pkt[:magic].should == 0x81
+        @pkt[:opcode].should == 0
+        @pkt.class.should == Memcached::Response
+      end
+      it "should return the right data type" do
+        @pkt[:data_type].should == 0
+      end
+      it "should return the right status" do
+        @pkt[:status].should == Memcached::Errors::NO_ERROR
+      end
+      it "should return the right opaque" do
+        @pkt[:opaque].should == 0
+      end
+      it "should return the right CAS" do
+        @pkt[:cas].should == 1
+      end
+      it "should parse the body correctly" do
+        @pkt[:key].should == ""
+        @pkt[:value].should == "World"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: astro-remcached
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Stephan Maka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby EventMachine memcached client
+email: astro@spaceboyz.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION.yml
+- lib/remcached.rb
+- lib/remcached/client.rb
+- lib/remcached/const.rb
+- lib/remcached/pack_array.rb
+- lib/remcached/packet.rb
+- spec/client_spec.rb
+- spec/memcached_spec.rb
+- spec/packet_spec.rb
+has_rdoc: false
+homepage: http://github.com/astro/remcached/
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 3
+summary: Ruby EventMachine memcached client
+test_files: 
+- spec/packet_spec.rb
+- spec/client_spec.rb
+- spec/memcached_spec.rb