multi_redis 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e26f3631e84ad497b9f973cf0bb51e7beadcaa1
-  data.tar.gz: e0c768e42521ff6d4ef1cd82a9927eedf77d7658
+  metadata.gz: 61930ec26bd7e401367fff65403353e02a6d9c7f
+  data.tar.gz: b9ac5d3857fea25471585dda965067e5509bfee6
 SHA512:
-  metadata.gz: 0bfab1e32e01f57ea87bdac95b3be65316fc22528f5638997407f51e84aa3ac80ffe0b65cbe3c70d38c314c41f0dddfb3a139043ae0c40c28a1d5e616209c5a0
-  data.tar.gz: a1eeac5efc8f63d1603ab45c70b0566f09231d34a719fb819dd30da6f688ce300095fed0736f244a5a01590dea6769e5de70daa60c9fa08be34a878398a7a870
+  metadata.gz: a1b888ede24eea2c0efb87dfc3db0e4b0cebdad0bd4114c101af9d34afe7d428976b38148d6bba12da701546f8083ad3d898ac0211d273adcc7f85ca8162a1d9
+  data.tar.gz: 39bee42c79812c41203c46029cfdebb3bbb07f6754bc47188f08a0065ee57ec804ad14e37cbefed9714123835fc9bd2ff83e1c981ffd5de6fa58adb53392c088

data/README.md

@@ -1,10 +1,140 @@
 # Multi Redis
 
+**Pattern to execute separate [redis-rb](https://github.com/redis/redis-rb) operations in the same command pipeline or multi/exec.**
+
 [![Gem Version](https://badge.fury.io/rb/multi_redis.png)](http://badge.fury.io/rb/multi_redis)
 [![Dependency Status](https://gemnasium.com/AlphaHydrae/multi_redis.png)](https://gemnasium.com/AlphaHydrae/multi_redis)
 [![Build Status](https://secure.travis-ci.org/AlphaHydrae/multi_redis.png)](http://travis-ci.org/AlphaHydrae/multi_redis)
 [![Coverage Status](https://coveralls.io/repos/AlphaHydrae/multi_redis/badge.png?branch=master)](https://coveralls.io/r/AlphaHydrae/multi_redis?branch=master)
 
+## Installation
+
+Put this in your Gemfile:
+
+```rb
+gem 'multi_redis', '~> 0.1.0'
+```
+
+Then run `bundle install`.
+
+## Usage
+
+Assume you have two separate methods that call redis:
+
+```rb
+$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]}"
+  end
+
+  def do_other_stuff
+    value = $redis.get 'key3'
+    "hey #{value}"
+  end
+end
+
+o = MyRedisClass.new
+o.do_stuff         #=> "value 1 is foo, value 2 is bar"
+o.do_other_stuff   #=> "hey baz"
+```
+
+This works, but the redis client executes two separate requests to the server:
+
+```
+Request 1:
+- MULTI
+- GET foo
+- GETSET bar newvalue
+- EXEC
+
+Request 2:
+- GET baz
+```
+
+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.
+
+Multi Redis provides a pattern to structure this code so that your separate redis calls may be executed together in one request when needed.
+
+```rb
+$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.
+do_stuff = MultiRedis::Operation.new do
+
+  # Multi blocks will be run atomically in a MULTI/EXEC.
+  # 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'
+  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.
+  run do |mr|
+    "value 1 is #{mr.data.value1}, value 2 is #{mr.data.value2}"
+  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"
+
+# Create the other redis operation.
+do_other_stuff = MultiRedis::Operation.new do
+
+  multi do |mr|
+    mr.data.value = $redis.get 'key3'
+  end
+
+  run do |mr|
+    "hey #{mr.data.value}"
+  end
+end
+
+result = do_other_stuff.execute   #=> "hey baz"
+```
+
+The two operations can still be executed separately like before, but they can also be combined through Multi Redis:
+
+```rb
+MultiRedis.execute do_stuff, do_other_stuff
+```
+
+All redis calls get grouped into the same MULTI/EXEC:
+
+```
+One request:
+- MULTI
+- GET foo
+- GETSET bar newvalue
+- GET baz
+- EXEC
+```
+
+The array of results is also returned by the `execute` call:
+
+```rb
+MultiRedis.execute do_stuff, do_other_stuff   #=> [ 'value 1 is foo, value 2 is bar', 'hey baz' ]
+```
+
 ## Meta
 
 * **Author:** Simon Oulevay (Alpha Hydrae)

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/multi_redis.rb

@@ -1,67 +1,180 @@
 require 'ostruct'
 require 'redis'
+require 'thread'
 
 module MultiRedis
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 
-  class Operation
+  @redis = nil
+  @mutex = Mutex.new
+  @executing = false
+  @operations = []
+  @arguments = []
 
-    def initialize *args, &block
+  def self.redis= redis
+    @redis = redis
+  end
 
-      options = args.last.kind_of?(Hash) ? args.pop : {}
+  def self.redis
+    @redis
+  end
+
+  def self.execute *args, &block
 
-      @target = args.shift || self
-      @redis = options[:redis] || Redis.new
-      @data = Data.new
-      @block = 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
 
-    def execute
-      instance_eval &@block
+    Executor.new(operations, args: arguments).execute
+  end
+
+  def self.executing?
+    @executing
+  end
+
+  def self.register_operation op, *args
+    op.tap do |op|
+      @operations << op
+      @arguments << args
     end
+  end
 
-    def multi &block
-      @data.to_a = @redis.multi do
-        @target.instance_exec @redis, @data, &block
+  module Extension
+
+    def multi_redis_operation symbol, options = {}, &block
+      op = Operation.new self, options, &block
+      define_method symbol do |*args|
+        op.execute *args
       end
-      @data.resolve_futures!
+      self
     end
+  end
 
-    def run &block
-      @target.instance_exec @data, &block
+  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
+
+      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 Data
+  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 = []
 
-    def initialize
-      @data = Hash.new
-      @results = []
+      DSL.new(self).instance_eval &block
     end
 
-    def method_missing symbol, *args, &block
-      if m = symbol.to_s.match(/\A(.*)\=\Z/)
-        @data[m[1].to_sym] = args[0]
+    def execute *args
+      if MultiRedis.executing?
+        MultiRedis.register_operation self, *args
       else
-        super symbol, *args, &block
+        Executor.new([ self ], args: [ args ], redis: @redis).execute.first
       end
     end
 
-    def resolve_futures!
-      @data.each_key do |k|
-        self.class.send(:define_method, k){ @data[k].value } if @data[k].is_a? Redis::Future
-        #@data[k] = @data[k].value if @data[k].is_a? Redis::Future
+    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
+
+      def run &block
+        @op.add_step &block
+      end
+    end
+  end
+
+  class Step
+
+    def initialize target, multi_type, block
+      @target, @multi_type, @block = target, multi_type, block
     end
 
-    def to_a
-      @results
+    def execute context, *args
+      @target.instance_exec *args.unshift(context), &@block
     end
 
-    def to_a= results
-      @results = results
+    def multi_type
+      @multi_type
     end
   end
 end
 
-#Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }
+Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }

data/lib/multi_redis/context.rb

@@ -0,0 +1,28 @@
+
+module MultiRedis
+
+  class Context
+    attr_accessor :last_results
+
+    def initialize redis
+      @last_results = []
+      @data = Data.new
+      @redis = redis
+    end
+
+    def redis
+      @redis
+    end
+
+    def data
+      @data
+    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
+      end
+      @last_results.collect!{ |r| r.is_a?(Redis::Future) ? r.value : r }
+    end
+  end
+end

data/lib/multi_redis/data.rb

@@ -0,0 +1,30 @@
+
+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
+
+    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]
+      else
+        super symbol, *args, &block
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_redis
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Simon Oulevay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-06 00:00:00.000000000 Z
+date: 2014-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -136,7 +136,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Multi redis.
+description: Allows you to organize your redis calls in separate classes but still
+  execute them atomically with pipelined or multi.
 email: git@alphahydrae.com
 executables: []
 extensions: []
@@ -149,6 +150,8 @@ files:
 - README.md
 - VERSION
 - lib/multi_redis.rb
+- lib/multi_redis/context.rb
+- lib/multi_redis/data.rb
 homepage: http://github.com/AlphaHydrae/multi_redis
 licenses:
 - MIT
@@ -172,5 +175,6 @@ rubyforge_project:
 rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: Multi redis.
+summary: Pattern to execute separate redis-rb operations in the same command pipeline
+  or multi/exec.
 test_files: []