astro-remcached 0.2.2 → 0.3.0

data/VERSION.yml

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

data/lib/remcached.rb

@@ -56,31 +56,98 @@ module Memcached
       hashed
     end
 
-    def operation(op, contents, &callback)
+
+    ##
+    # Memcached operations
+    ##
+
+    def operation(request_klass, contents, &callback)
       client = client_for_key(contents[:key])
       if client
-        client.send(op, contents, &callback)
+        client.send_request request_klass.new(contents), &callback
       elsif callback
         callback.call :status => Errors::DISCONNECTED
       end
     end
 
-
-    ##
-    # Memcached operations
-    ##
-
     def add(contents, &callback)
-      operation :add, contents, &callback
+      operation Request::Add, contents, &callback
     end
     def get(contents, &callback)
-      operation :get, contents, &callback
+      operation Request::Get, contents, &callback
     end
     def set(contents, &callback)
-      operation :set, contents, &callback
+      operation Request::Set, contents, &callback
     end
     def delete(contents, &callback)
-      operation :delete, contents, &callback
+      operation Request::Delete, contents, &callback
+    end
+
+
+    ##
+    # Multi operations
+    #
+    ##
+
+    def multi_operation(request_klass, contents_list, &callback)
+      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/lib/remcached/client.rb

@@ -129,23 +129,6 @@ module Memcached
       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|

data/lib/remcached/const.rb

@@ -25,6 +25,10 @@ module Memcached
     DECREMENT = 0x06
     QUIT = 0x07
     STAT = 0x10
+    GETQ = 0x09
+    SETQ = 0x11
+    ADDQ = 0x12
+    DELETEQ = 0x14
 
 =begin
    Possible values of the one-byte field:

data/lib/remcached/packet.rb

@@ -2,6 +2,8 @@ require 'remcached/pack_array'
 
 module Memcached
   class Packet
+    ##
+    # Initialize with fields
     def initialize(contents={})
       @contents = contents
       (self.class.fields +
@@ -10,15 +12,20 @@ module Memcached
       end
     end
 
+    ##
+    # Get field
     def [](field)
       @contents[field]
     end
 
+    ##
+    # Set field
     def []=(field, value)
       @contents[field] = value
     end
 
-    # Define fields for subclasses
+    ##
+    # Define a field for subclasses
     def self.field(name, packed, default=nil)
       instance_eval do
         @fields ||= []
@@ -26,6 +33,8 @@ module Memcached
       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 : []
@@ -33,6 +42,8 @@ module Memcached
       parent_fields + class_fields
     end
 
+    ##
+    # Define an extra for subclasses
     def self.extra(name, packed, default=nil)
       instance_eval do
         @extras ||= []
@@ -40,10 +51,17 @@ module Memcached
       end
     end
 
+    ##
+    # Extras of this class
     def self.extras
-      instance_eval { @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)
@@ -56,7 +74,11 @@ module Memcached
       new contents
     end
 
-    # Return remaining bytes
+    ##
+    # 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]
 
@@ -75,6 +97,8 @@ module Memcached
       rest
     end
 
+    ##
+    # Serialize for wire
     def to_s
       extras_s = extras_to_s
       key_s = self[:key].to_s
@@ -154,7 +178,13 @@ module Memcached
 
     class Get < Request
       def initialize(contents)
-        super(contents.merge :opcode=>Commands::GET)
+        super({:opcode=>Commands::GET}.merge(contents))
+      end
+
+      class Quiet < Get
+        def initialize(contents)
+          super({:opcode=>Commands::GETQ}.merge(contents))
+        end
       end
     end
 
@@ -163,7 +193,13 @@ module Memcached
       extra :expiration, 'N', 0
 
       def initialize(contents)
-        super(contents.merge :opcode=>Commands::ADD)
+        super({:opcode=>Commands::ADD}.merge(contents))
+      end
+
+      class Quiet < Add
+        def initialize(contents)
+          super({:opcode=>Commands::ADDQ}.merge(contents))
+        end
       end
     end
 
@@ -172,19 +208,31 @@ module Memcached
       extra :expiration, 'N', 0
 
       def initialize(contents)
-        super(contents.merge :opcode=>Commands::SET)
+        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(contents.merge :opcode=>Commands::DELETE)
+        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(contents.merge :opcode=>Commands::STAT)
+        super({:opcode=>Commands::STAT}.merge(contents))
       end
     end
   end

data/remcached.gemspec

@@ -1,12 +1,15 @@
+# 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.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Stephan Maka"]
-  s.date = %q{2009-09-12}
+  s.date = %q{2009-09-17}
   s.description = %q{Ruby EventMachine memcached client}
   s.email = %q{astro@spaceboyz.net}
   s.files = [
@@ -26,12 +29,12 @@ Gem::Specification.new do |s|
   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.rubygems_version = %q{1.3.4}
   s.summary = %q{Ruby EventMachine memcached client}
   s.test_files = [
-    "spec/client_spec.rb",
-     "spec/memcached_spec.rb",
-     "spec/packet_spec.rb"
+    "spec/packet_spec.rb",
+     "spec/client_spec.rb",
+     "spec/memcached_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/client_spec.rb

@@ -14,122 +14,6 @@ describe Memcached::Client do
   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 = {}

data/spec/memcached_spec.rb

@@ -1,15 +1,15 @@
 $: << File.dirname(__FILE__) + '/../lib'
 require 'remcached'
 
-describe Memcached::Client do
+describe Memcached 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
+      @timer = EM::PeriodicTimer.new(0.01) do
+        # at least localhost & localhost
+        if Memcached.usable_clients.length >= 2
+          @timer.cancel
           block.call
         end
       end
@@ -21,6 +21,125 @@ describe Memcached::Client do
     EM.stop
   end
 
+
+  context "when doing a simple operation" do
+    it "should add a value" do
+      run do
+        Memcached.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
+        Memcached.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
+        Memcached.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
+        Memcached.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
+        Memcached.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
+        Memcached.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
+          Memcached.set(:key => 'counter',
+                  :value => '0') do |result|
+            stop
+          end
+        end
+      end
+
+      it "should count #{$n} times" do
+        @counted = 0
+        def count
+          Memcached.get(:key => 'counter') do |result|
+            result[:status].should == Memcached::Errors::NO_ERROR
+            value = result[:value].to_i
+            Memcached.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
+          Memcached.get(:key => 'counter') do |result|
+            result[:status].should == Memcached::Errors::NO_ERROR
+            result[:value].to_i.should == $n
+            stop
+          end
+        end
+      end
+    end
+  end
+
   context "when using multiple servers" do
     it "should not return the same hash for the succeeding key" do
       run do
@@ -56,4 +175,81 @@ describe Memcached::Client do
     end
   end
 
+  context "when manipulating multiple records at once" do
+    before :all do
+      @n = 10
+    end
+
+    def key(n)
+      "test:item:#{n}"
+    end
+
+    it "should add some items" do
+      run do
+        items = []
+        @n.times { |i|
+          items << { :key => key(i),
+                     :value => 'Foo',
+                     :expiration => 20 } if i % 2 ==  0
+        }
+        Memcached.multi_add(items) { |responses|
+          stop
+          @n.times { |i|
+            if i % 2 == 0 && (response_i = responses[key(i)])
+              response_i[:status].should == Memcached::Errors::NO_ERROR
+            end
+          }
+        }
+      end
+    end
+
+    it "should get all items" do
+      run do
+        items = []
+        @n.times { |i|
+          items << { :key => key(i) }
+        }
+        Memcached.multi_get(items) { |responses|
+          stop
+          @n.times { |i|
+            if i % 2 == 0
+              responses.should have_key(key(i))
+              responses[key(i)][:status].should == Memcached::Errors::NO_ERROR
+              responses[key(i)][:value].should == 'Foo'
+            else
+              # either no response because request was quiet, or not
+              # found in case of last response
+              if (response_i = responses[key(i)])
+                response_i[:status].should == Memcached::Errors::KEY_NOT_FOUND
+              end
+            end
+          }
+        }
+      end
+    end
+
+    it "should delete all items" do
+      run do
+        items = []
+        @n.times { |i|
+          items << { :key => key(i) }
+        }
+        Memcached.multi_delete(items) { |responses|
+          stop
+          @n.times { |i|
+            if i % 2 == 0
+              # either no response because request was quiet, or ok in
+              # case of last response
+              if (response_i = responses[key(i)])
+                response_i[:status].should == Memcached::Errors::NO_ERROR
+              end
+            else
+              responses[key(i)][:status].should == Memcached::Errors::KEY_NOT_FOUND
+            end
+          }
+        }
+      end
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: astro-remcached
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors: 
 - Stephan Maka
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-12 00:00:00 -07:00
+date: 2009-09-17 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -62,6 +62,6 @@ signing_key:
 specification_version: 3
 summary: Ruby EventMachine memcached client
 test_files: 
+- spec/packet_spec.rb
 - spec/client_spec.rb
 - spec/memcached_spec.rb
-- spec/packet_spec.rb