multi_redis 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61930ec26bd7e401367fff65403353e02a6d9c7f
-  data.tar.gz: b9ac5d3857fea25471585dda965067e5509bfee6
+  metadata.gz: 679e1a349b9f03a3c6c16634f9a5e8b2051ae5ca
+  data.tar.gz: 940d7c657fa3dd83977a536e78e44d366c910072
 SHA512:
-  metadata.gz: a1b888ede24eea2c0efb87dfc3db0e4b0cebdad0bd4114c101af9d34afe7d428976b38148d6bba12da701546f8083ad3d898ac0211d273adcc7f85ca8162a1d9
-  data.tar.gz: 39bee42c79812c41203c46029cfdebb3bbb07f6754bc47188f08a0065ee57ec804ad14e37cbefed9714123835fc9bd2ff83e1c981ffd5de6fa58adb53392c088
+  metadata.gz: 5b47def10a775566a8c70cd4b3bbddef629349ebdfe197c2daf6170df572f872a9d7b090fd24d6e530eaf9ffe0067d8314a915aff6d9a8d0ad9eb77374c96e16
+  data.tar.gz: ceeca19ecbd97dd7a51ab6dd9d5f4d5b30391bdc8980e0c7eced2f7f45c3c1ebc7e074b74664bf5bb1066eb79378e20c96c6e5aaab1d275853f27beb21d0ae29

data/Gemfile

@@ -2,15 +2,12 @@ source "https://rubygems.org"
 
 gem 'redis', '~> 3.0'
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem 'bundler'
-  gem 'rake'
-  gem 'rspec'
-  gem 'jeweler'
-  gem 'gem-release'
-  gem 'rake-version'
-  gem 'simplecov'
-  gem 'coveralls', require: false
+  gem 'bundler', '~> 1.5'
+  gem 'rake', '~> 10.1'
+  gem 'rspec', '~> 2.14'
+  gem 'jeweler', '~> 2.0'
+  gem 'rake-version', '~> 0.4'
+  gem 'simplecov', '~> 0.8'
+  gem 'coveralls', '~> 0.7', require: false
 end

data/README.md

@@ -25,48 +25,46 @@ Assume you have two separate methods that call redis:
 $redis = Redis.new
 $redis.set 'key1', 'foo'
 $redis.set 'key2', 'bar'
-$redis.set 'key3', 'baz'
 
 class MyRedisClass
 
   def do_stuff
-
-    # run two calls atomically in a MULTI/EXEC
-    values = $redis.multi do
-      $redis.get 'key1'
-      $redis.getset 'key2', 'newvalue'
-    end
-
-    "value 1 is #{values[0]}, value 2 is #{values[1]}"
+    $redis.get 'key1'
   end
 
   def do_other_stuff
-    value = $redis.get 'key3'
-    "hey #{value}"
+    $redis.get 'key2'
   end
 end
 
 o = MyRedisClass.new
-o.do_stuff         #=> "value 1 is foo, value 2 is bar"
-o.do_other_stuff   #=> "hey baz"
+o.do_stuff         #=> "foo"
+o.do_other_stuff   #=> "bar"
 ```
 
-This works, but the redis client executes two separate requests to the server:
+This works, but the redis client executes two separate requests to the server, and waits for the result of the first one to start the second one:
 
 ```
 Request 1:
-- MULTI
-- GET foo
-- GETSET bar newvalue
-- EXEC
+- GET key1
 
 Request 2:
-- GET baz
+- GET key2
+```
+
+`redis-rb` allows you to run both in the same command pipeline:
+
+```rb
+results = $redis.pipelined do
+  $redis.get 'key1'
+  $redis.get 'key2'
+end
+
+results[0]   #=> "foo"
+results[1]   #=> "bar"
 ```
 
-The client will wait for the response from the first request before starting the second one.
-One round trip could be saved by executing the second request in the same MULTI/EXEC block.
-But it would be hard to refactor these two methods to do that while still keeping them separate.
+But it would be hard to refactor the two methods to use a pipeline while still keeping them separate.
 
 Multi Redis provides a pattern to structure this code so that your separate redis calls may be executed together in one request when needed.
 
@@ -74,42 +72,39 @@ Multi Redis provides a pattern to structure this code so that your separate redi
 $redis = Redis.new
 $redis.set 'key1', 'foo'
 $redis.set 'key2', 'bar'
-$redis.set 'key3', 'baz'
 
-# Create a redis operation, i.e. an operation that performs redis calls.
+# Create a redis operation, i.e. an operation that performs redis calls, for the first method.
 do_stuff = MultiRedis::Operation.new do
 
-  # Multi blocks will be run atomically in a MULTI/EXEC.
+  # Pipelined blocks will be run in a command pipeline.
   # All redis commands will return futures inside this block, so you can't use the values immediately.
-  # Store futures in the provided data object for later use.
-  multi do |mr|
-    mr.data.value1 = $redis.get 'key1'
-    mr.data.value2 = $redis.getset 'key2', 'newvalue'
+  pipelined do |mr|
+    $redis.get 'key1'
   end
 
-  # Run blocks are executed after the previous multi block (or blocks) are completed and all futures have been resolved.
-  # The data object now contains the values of the futures you stored.
+  # This run block will be executed after the pipelined block is completed and all futures have been resolved.
+  # The #last_replies method of the Multi Redis context will return the results of all redis calls in the pipelined block.
   run do |mr|
-    "value 1 is #{mr.data.value1}, value 2 is #{mr.data.value2}"
+    mr.last_replies[0]   # => "foo"
   end
 end
 
-# The return value of the operation is that of the last run block.
-result = do_stuff.execute   #=> "value 1 is foo, value 2 is bar"
+# The return value of the operation is that of the last block.
+result = do_stuff.execute   #=> "foo"
 
-# Create the other redis operation.
+# Create the redis operation for the other method.
 do_other_stuff = MultiRedis::Operation.new do
 
   multi do |mr|
-    mr.data.value = $redis.get 'key3'
+    $redis.get 'key2'
   end
 
   run do |mr|
-    "hey #{mr.data.value}"
+    mr.last_replies[0]   #=> "bar"
   end
 end
 
-result = do_other_stuff.execute   #=> "hey baz"
+result = do_other_stuff.execute   #=> "bar"
 ```
 
 The two operations can still be executed separately like before, but they can also be combined through Multi Redis:
@@ -118,21 +113,18 @@ The two operations can still be executed separately like before, but they can al
 MultiRedis.execute do_stuff, do_other_stuff
 ```
 
-All redis calls get grouped into the same MULTI/EXEC:
+Both redis calls get grouped into the same command pipeline:
 
 ```
 One request:
-- MULTI
 - GET foo
-- GETSET bar newvalue
-- GET baz
-- EXEC
+- GET bar
 ```
 
-The array of results is also returned by the `execute` call:
+The array of results is returned by the `execute` call:
 
 ```rb
-MultiRedis.execute do_stuff, do_other_stuff   #=> [ 'value 1 is foo, value 2 is bar', 'hey baz' ]
+MultiRedis.execute do_stuff, do_other_stuff   #=> [ "foo", "bar" ]
 ```
 
 ## Meta

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/multi_redis.rb

@@ -1,179 +1,39 @@
-require 'ostruct'
 require 'redis'
-require 'thread'
 
 module MultiRedis
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 
-  @redis = nil
-  @mutex = Mutex.new
-  @executing = false
-  @operations = []
-  @arguments = []
-
-  def self.redis= redis
-    @redis = redis
-  end
-
-  def self.redis
-    @redis
+  class << self
+    attr_accessor :redis
   end
 
   def self.execute *args, &block
 
-    operations, arguments = @mutex.synchronize do
-      @operations = args.dup
-      @arguments = []
-      @executing = true
-      yield if block_given?
-      @executing = false
-      [ @operations.dup.tap{ |ops| @operations.clear }, @arguments ]
-    end
-
-    Executor.new(operations, args: arguments).execute
-  end
-
-  def self.executing?
-    @executing
-  end
+    options = args.last.kind_of?(Hash) ? args.pop : {}
 
-  def self.register_operation op, *args
-    op.tap do |op|
-      @operations << op
-      @arguments << args
+    executor = nil
+    @mutex.synchronize do
+      @executor = Executor.new options
+      args.each{ |op| @executor.add op }
+      yield if block_given?
+      executor = @executor
+      @executor = nil
     end
-  end
-
-  module Extension
 
-    def multi_redis_operation symbol, options = {}, &block
-      op = Operation.new self, options, &block
-      define_method symbol do |*args|
-        op.execute *args
-      end
-      self
-    end
+    executor.execute
   end
 
-  class Executor
-    
-    def initialize operations, options = {}
-      @operations = operations
-      @arguments = options[:args] || []
-      @redis = options[:redis]
-    end
-
-    def execute options = {}
-
-      redis = @redis || MultiRedis.redis
-      contexts = Array.new(@operations.length){ |i| Context.new redis }
-      stacks = @operations.collect{ |op| op.steps.dup }
-      args = stacks.collect.with_index{ |a,i| @arguments[i] || [] }
-      final_results = Array.new @operations.length
+  private
 
-      while stacks.any? &:any?
-
-        # execute all non-multi steps
-        stacks.each_with_index do |steps,i|
-          final_results[i] = steps.shift.execute(contexts[i], args[i]) while steps.first && !steps.first.multi_type
-        end
-
-        # execute all pipelined steps, if any
-        pipelined_steps = stacks.collect{ |steps| steps.first && steps.first.multi_type == :pipelined ? steps.shift : nil }
-        if pipelined_steps.any?
-          results = []
-          redis.pipelined do
-            pipelined_steps.each_with_index do |step,i|
-              if step
-                final_results[i] = step.execute(contexts[i], args[i])
-                contexts[i].last_results = redis.client.futures[results.length, redis.client.futures.length]
-                results += contexts[i].last_results
-              end
-            end
-          end
-          pipelined_steps.each_with_index{ |step,i| contexts[i].resolve_futures! if step }
-        end
-
-        # execute all multi steps, if any
-        multi_steps = stacks.collect{ |steps| steps.first && steps.first.multi_type == :multi ? steps.shift : nil }
-        if multi_steps.any?
-          results = []
-          redis.multi do
-            multi_steps.each_with_index do |step,i|
-              if step
-                final_results[i] = step.execute(contexts[i], args[i])
-                contexts[i].last_results = redis.client.futures[results.length, redis.client.futures.length]
-                results += contexts[i].last_results
-              end
-            end
-          end
-          multi_steps.each_with_index{ |step,i| contexts[i].resolve_futures! if step }
-        end
-      end
-
-      final_results
-    end
-  end
-
-  class Operation
-    attr_reader :steps
-
-    def initialize *args, &block
-
-      options = args.last.kind_of?(Hash) ? args.pop : {}
-
-      @target = args.shift || options[:target] || self
-      @redis = options[:redis]
-      @steps = []
-
-      DSL.new(self).instance_eval &block
-    end
-
-    def execute *args
-      if MultiRedis.executing?
-        MultiRedis.register_operation self, *args
-      else
-        Executor.new([ self ], args: [ args ], redis: @redis).execute.first
-      end
-    end
-
-    def add_step multi_type = nil, &block
-      @steps << Step.new(@target, multi_type, block)
-    end
-
-    class DSL
-
-      def initialize op
-        @op = op
-      end
-
-      def multi &block
-        @op.add_step :multi, &block
-      end
-
-      def pipelined &block
-        @op.add_step :pipelined, &block
-      end
+  @mutex = Mutex.new
+  @executor = nil
 
-      def run &block
-        @op.add_step &block
-      end
-    end
+  def self.executor
+    @executor
   end
 
-  class Step
-
-    def initialize target, multi_type, block
-      @target, @multi_type, @block = target, multi_type, block
-    end
-
-    def execute context, *args
-      @target.instance_exec *args.unshift(context), &@block
-    end
-
-    def multi_type
-      @multi_type
-    end
+  def self.executing?
+    !!@executor
   end
 end
 

data/lib/multi_redis/context.rb

@@ -1,13 +1,28 @@
-
 module MultiRedis
 
   class Context
-    attr_accessor :last_results
+    attr_accessor :last_result
+    attr_accessor :last_replies
 
-    def initialize redis
-      @last_results = []
-      @data = Data.new
+    def initialize redis, shared_context = nil
       @redis = redis
+      @data = Data.new
+      @last_replies = []
+      @shared_context = shared_context
+    end
+
+    def execute operation, *args
+      @last_result = operation.execute self, *args
+      if @resolve = @redis.client.respond_to?(:futures)
+        @last_replies = @redis.client.futures[@shared_context.last_replies.length, @redis.client.futures.length]
+        @shared_context.last_replies.concat @last_replies
+      end
+      @shared_context.last_result = @last_result
+      @last_result
+    end
+
+    def shared
+      @shared_context
     end
 
     def redis
@@ -19,10 +34,11 @@ module MultiRedis
     end
 
     def resolve_futures!
-      @data.contents.each_key do |k|
-        @data.contents[k] = @data.contents[k].value if @data.contents[k].is_a? Redis::Future
+      return unless @resolve
+      @data.each_key do |k|
+        @data[k] = @data[k].value if @data[k].is_a? Redis::Future
       end
-      @last_results.collect!{ |r| r.is_a?(Redis::Future) ? r.value : r }
+      @last_replies.collect!{ |r| r.is_a?(Redis::Future) ? r.value : r }
     end
   end
 end

data/lib/multi_redis/data.rb

@@ -1,27 +1,14 @@
-
 module MultiRedis
 
-  class Data
-    attr_reader :contents
-
-    def initialize
-      @contents = Hash.new
-    end
-
-    def [] k
-      @contents[k]
-    end
-
-    def []= k, v
-      @contents[k.to_sym] = v
-    end
+  class Data < Hash
 
     def method_missing symbol, *args, &block
-      if @contents.key? symbol
-        @contents[symbol]
-      elsif m = symbol.to_s.match(/\A(.*)\=\Z/)
-        raise "Reserved name" if respond_to? acc = m[1].to_sym
-        @contents[acc] = args[0]
+      if args.empty?
+        self[symbol]
+      elsif args.length == 1 && m = symbol.to_s.match(/\A(.*)\=\Z/)
+        acc = m[1].to_sym
+        raise ArgumentError, "Cannot set property #{acc}, method ##{acc} already exists" if respond_to? acc
+        self[acc] = args[0]
       else
         super symbol, *args, &block
       end

data/lib/multi_redis/executor.rb

@@ -0,0 +1,97 @@
+module MultiRedis
+
+  class Executor
+
+    def initialize options = {}
+      @operations = []
+      @redis = options[:redis]
+    end
+
+    def add operation, *args
+      @operations << { op: operation, args: args }
+    end
+
+    def execute options = {}
+
+      redis = @redis || MultiRedis.redis
+      shared_context = Context.new redis
+
+      total = 0
+      execution = @operations.collect do |operation|
+        total += operation[:op].steps.length
+        OperationExecution.new operation[:op], operation[:args], shared_context
+      end
+
+      while execution.any?{ |oe| !oe.done? } && total >= 1
+        total -= 1 # safeguard against infinite loop
+
+        TYPES.each do |type|
+
+          execution.each do |oe|
+            oe.execute_current_step while oe.next? :call
+          end
+
+          if execution.any?{ |oe| oe.next? type }
+            shared_context.last_replies.clear
+            redis.send type do
+              execution.each do |oe|
+                oe.execute_current_step if oe.next? type
+              end
+            end
+            execution.each{ |oe| oe.resolve_futures! }
+          end
+        end
+      end
+
+      execution.each{ |oe| oe.resolve_operation_future! }
+      execution.collect!{ |oe| oe.final_results }
+    end
+
+    private
+
+    TYPES = [ :pipelined, :multi ]
+    
+    class OperationExecution
+      attr_reader :final_results
+
+      def initialize operation, args, shared_context
+
+        @operation = operation
+        @args = args
+
+        @context = Context.new shared_context.redis, shared_context
+        @steps = operation.steps
+
+        @current_index = 0
+      end
+
+      def done?
+        !current_step
+      end
+
+      def next? type
+        current_step && current_step.type == type
+      end
+
+      def execute_current_step
+        results = @context.execute current_step, *@args
+        @current_index += 1
+        @final_results = results
+      end
+
+      def resolve_futures!
+        @context.resolve_futures!
+      end
+
+      def resolve_operation_future!
+        @operation.future.value = @final_results if @operation.future
+      end
+
+      private
+
+      def current_step
+        @steps[@current_index]
+      end
+    end
+  end
+end

data/lib/multi_redis/extension.rb

@@ -0,0 +1,13 @@
+module MultiRedis
+
+  module Extension
+
+    def multi_redis_operation symbol, options = {}, &block
+      op = Operation.new options.merge(target: self), &block
+      define_method symbol do |*args|
+        op.execute *args
+      end
+      self
+    end
+  end
+end

data/lib/multi_redis/future.rb

@@ -0,0 +1,23 @@
+module MultiRedis
+
+  class FutureNotReady < RuntimeError
+    
+      def initialize
+        super "Value will be available once the operation executes."
+      end
+    end
+
+  class Future
+    FutureNotReady = ::MultiRedis::FutureNotReady.new
+    attr_writer :value
+    
+    def initialize value = nil
+      @value = value || FutureNotReady
+    end
+
+    def value
+      raise @value if @value.kind_of? RuntimeError
+      @value
+    end
+  end
+end

data/lib/multi_redis/operation.rb

@@ -0,0 +1,61 @@
+module MultiRedis
+
+  class Operation
+    attr_accessor :redis
+    attr_reader :steps, :future
+
+    def initialize options = {}, &block
+
+      @target = options[:target] || self
+      @redis = options[:redis]
+      @steps = []
+
+      configure &block if block
+    end
+
+    def configure &block
+      DSL.new(self).instance_eval &block
+    end
+
+    def execute *args
+      if MultiRedis.executing?
+        MultiRedis.executor.add self, *args
+        @future = Future.new
+      else
+        e = Executor.new redis: @redis
+        e.add self, *args
+        e.execute.first.tap do |result|
+          @future = Future.new result
+        end
+      end
+    end
+
+    def add type, &block
+      raise ArgumentError, "Unknown type #{type}, must be one of #{TYPES.join ', '}." unless TYPES.include? type
+      @steps << Step.new(@target, type, block)
+    end
+
+    private
+
+    TYPES = [ :call, :pipelined, :multi ]
+
+    class DSL
+
+      def initialize op
+        @op = op
+      end
+
+      def multi &block
+        @op.add :multi, &block
+      end
+
+      def pipelined &block
+        @op.add :pipelined, &block
+      end
+
+      def run &block
+        @op.add :call, &block
+      end
+    end
+  end
+end

data/lib/multi_redis/step.rb

@@ -0,0 +1,17 @@
+module MultiRedis
+
+  class Step
+
+    def initialize target, type, block
+      @target, @type, @block = target, type, block
+    end
+
+    def execute context, *args
+      @target.instance_exec *args.unshift(context), &@block
+    end
+
+    def type
+      @type
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_redis
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Simon Oulevay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-09 00:00:00.000000000 Z
+date: 2014-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -28,114 +28,100 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: gem-release
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake-version
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 description: Allows you to organize your redis calls in separate classes but still
   execute them atomically with pipelined or multi.
 email: git@alphahydrae.com
@@ -152,6 +138,11 @@ files:
 - lib/multi_redis.rb
 - lib/multi_redis/context.rb
 - lib/multi_redis/data.rb
+- lib/multi_redis/executor.rb
+- lib/multi_redis/extension.rb
+- lib/multi_redis/future.rb
+- lib/multi_redis/operation.rb
+- lib/multi_redis/step.rb
 homepage: http://github.com/AlphaHydrae/multi_redis
 licenses:
 - MIT