abstractivator 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a894768eba016b4434a8b631edd7206ddf500ab
-  data.tar.gz: b046f6c118d727a4e1d016147a77cb7e5e53fb81
+  metadata.gz: 58e09417a37a0401715ae76dd45139fe0b5cba42
+  data.tar.gz: f7d97a9ff2a8b887022ab5bf80f05f35f7c2f97a
 SHA512:
-  metadata.gz: 2fe54299e0af9aa942fb870e40dffcf6543b4910a6d060048334f21aa69ed555d727390ae24cfa2097bbe3e8dc5d001ce2988db9379af64927e68b7be5e11723
-  data.tar.gz: e9b6affbe39f825295dc91a3f3e3f1cc6440f92ac69b34d3803c358dfa8050dd8c7a3a1343f0b53a8a73242844e563ab2ad9b393406b6fc1631ae75adc740e2d
+  metadata.gz: 0982af424cdd32e91469cadbbb54de940b9872c09de0a2170af1896fe856d5474d4e59ee402a47005e1e11223d5b70764292712c301fe2672f8b4a7693208ddb
+  data.tar.gz: 8baad053d8a4dcec57c37ebb2ecc50bb8d1179402ac105989160fda70cf6fcfc8ac18012a4ddfed68397c87bb1a7e07272e9e960ba89f17da2db3a81bebd9c32

data/lib/abstractivator/fiber_defer.rb

@@ -7,17 +7,92 @@ rescue => e
 end
 
 module Abstractivator
+
+  # Provides a pair of functions for handling long-running requests in a thread pool.
+  # Uses fibers to maintain a somewhat normal coding style (hides explicit continuations).
+  # with_fiber_defer defines the lexical scope of all work being done.
+  # fiber_defer defines the portion of the work to be done in the worker thread.
+  # Control passes from the calling thread, to the worker thread, and back to the calling thread.
+  # The code is capable of propagating thread variables (e.g., Mongoid::Threaded.database_override)
+  # across these thread/fiber transitions.
+  # See EventMachine::defer for more information.
   module FiberDefer
     ROOT_FIBER = Fiber.current
 
-    def with_fiber_defer(&block)
+    def with_fiber_defer(thread_var_guard=nil, &block)
       raise 'this method requires an eventmachine reactor to be running' unless EM.reactor_running?
-      Fiber.new{block.call}.resume if block
+      raise 'with_fiber_defer cannot be nested within with_fiber_defer' if Thread.current[:fiber_defer_guard_proc]
+      raise 'with_fiber_defer cannot be nested within fiber_defer' if Thread.current[:inside_fiber_defer]
+      return unless block
+      guard_proc = make_guard_proc(thread_var_guard)
+      f = Fiber.new do
+        guard_proc.call
+        begin
+          Thread.current[:fiber_defer_guard_proc] = guard_proc # make available to fiber_defer calls
+          block.call
+        ensure
+          Thread.current[:fiber_defer_guard_proc] = nil
+        end
+      end
+      f.resume
     end
 
-    def fiber_defer(&action)
-      f = Fiber.current
+    def fiber_defer(thread_var_guard=nil, &action)
+      # we start out in the caller thread
+      inherited_guard_proc = Thread.current[:fiber_defer_guard_proc]
+      raise 'fiber_defer cannot be nested within fiber_defer' if Thread.current[:inside_fiber_defer]
+      raise 'fiber_defer must be called within a with_fiber_defer block' unless inherited_guard_proc
       raise 'fiber_defer must be passed an action to defer (the block)' unless action
+      local_guard_proc = make_guard_proc(thread_var_guard)
+      guard_proc = proc do
+        inherited_guard_proc.call
+        local_guard_proc.call
+      end
+      begin
+        basic_fiber_defer do
+          # in the background thread now
+          begin
+            Thread.current[:inside_fiber_defer] = true
+            guard_proc.call
+            action.call
+          ensure
+            Thread.current[:inside_fiber_defer] = false
+          end
+        end
+      ensure
+        # back in the caller thread
+        guard_proc.call
+      end
+    end
+
+    def mongoid_fiber_defer(&action)
+      thread_vars = {
+        Mongoid::Threaded.database_override => proc { |db| Mongoid.override_database(db) }
+      }
+      fiber_defer(thread_vars, &action)
+    end
+
+    private
+
+    def make_guard_proc(x)
+      case x
+      when Proc
+        x
+      when Hash
+        proc do
+          x.each do |value, setter|
+            setter.call(value)
+          end
+        end
+      when nil
+        proc { }
+      else
+        raise "Cannot turn #{x.inspect} into a guard proc"
+      end
+    end
+
+    def basic_fiber_defer(&action)
+      f = Fiber.current
       raise 'fiber_defer must be called within a with_fiber_defer block' if f == ROOT_FIBER
 
       safe_action = proc do
@@ -33,18 +108,5 @@ module Abstractivator
       raise error if error
       result
     end
-
-    def mongoid_fiber_defer(&action)
-      db = Mongoid::Threaded.database_override
-      begin
-        fiber_defer do
-          # in the background thread
-          Mongoid.override_database(db) # set the db to what it was in the main thread
-          action.call
-        end
-      ensure
-        Mongoid.override_database(db) # main thread has moved on before we resume here. restore the db override.
-      end
-    end
   end
 end

data/lib/abstractivator/version.rb

@@ -1,3 +1,3 @@
 module Abstractivator
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/spec/lib/abstractivator/fiber_defer_spec.rb

@@ -7,38 +7,90 @@ describe Abstractivator::FiberDefer do
   include Abstractivator::FiberDefer
 
   describe '#with_fiber_defer' do
-    context 'when an eventmachine reactor is not running' do
-      it 'raises an error' do
-        expect{with_fiber_defer}.to raise_error /reactor/
+    it 'raises an error when an eventmachine reactor is not running' do
+      expect{with_fiber_defer}.to raise_error /reactor/
+    end
+    it 'does nothing when no block is provided' do
+      EM.run do
+        with_fiber_defer
+        EM.stop
+      end
+    end
+    it 'calls the block' do
+      EM.run do
+        expect{|b| with_fiber_defer(&b)}.to yield_control
+        EM.stop
       end
     end
-    context 'when an eventmachine reactor is running' do
-      it 'calls the block' do
+    context 'when a proc guard is provided' do
+      it 'invokes the guard upon entering the block' do
+        called_it = false
+        guard = proc { called_it = true }
         EM.run do
-          expect{|b| with_fiber_defer(&b)}.to yield_control
-          EM.stop
+          with_fiber_defer(guard) do
+            expect(called_it).to be true
+            EM.stop
+          end
         end
       end
-      context 'when no block is provided' do
-        it 'does nothing' do
-          EM.run do
-            with_fiber_defer
+    end
+    context 'when a hash guard is provided' do
+      before(:each) { Thread.current[:meaning] = 42 }
+      after(:each) { Thread.current[:meaning] = nil }
+      it 'propagates the thread/fiber-local variables into the block' do
+        EM.run do
+          guard = {
+            Thread.current[:meaning] => proc { |x| Thread.current[:meaning] = x }
+          }
+          with_fiber_defer(guard) do
+            expect(Thread.current[:meaning]).to eql 42
             EM.stop
           end
         end
       end
     end
+    context 'when an invalid guard is provided' do
+      it 'raises an error' do
+        EM.run do
+          expect{with_fiber_defer(3){ }}.to raise_error /guard/
+          EM.stop
+        end
+      end
+    end
+    it 'cannot be nested in with_fiber_defer' do
+      EM.run do
+        with_fiber_defer do
+          expect{with_fiber_defer{}}.to raise_error /nested/
+          EM.stop
+        end
+      end
+    end
+    it 'cannot be nested in fiber_defer' do
+      EM.run do
+        with_fiber_defer do
+          fiber_defer do
+            expect{with_fiber_defer{}}.to raise_error /nested/
+          end
+          EM.stop
+        end
+      end
+    end
   end
 
   describe '#fiber_defer' do
-    context 'when it is called outside a with_fiber_defer block' do
+    context 'when called outside a with_fiber_defer block' do
       it 'raises an error' do
         expect{fiber_defer{}}.to raise_error /with_fiber_defer/
       end
     end
     context 'when it is not passed a block' do
       it 'raises an error' do
-        expect{fiber_defer}.to raise_error /must be passed an action/
+        EM.run do
+          with_fiber_defer do
+            expect{fiber_defer}.to raise_error /must be passed an action/
+            EM.stop
+          end
+        end
       end
     end
     it 'executes the block on a background thread' do
@@ -95,6 +147,108 @@ describe Abstractivator::FiberDefer do
         end
       end
     end
+    context 'when a proc guard is provided' do
+      it 'invokes the guard upon entering and exiting the block' do
+        called_count = 0
+        guard = proc { called_count += 1 }
+        EM.run do
+          with_fiber_defer do
+            fiber_defer(guard) do
+              expect(called_count).to eql 1
+            end
+            expect(called_count).to eql 2
+            EM.stop
+          end
+        end
+      end
+      context 'and an inherited guard is provided' do
+        it 'invokes the inherited guard and then the local guard upon entering and exiting the block' do
+          the_log = []
+          guard1 = proc { the_log << 'guard1' }
+          guard2 = proc { the_log << 'guard2' }
+          EM.run do
+            with_fiber_defer(guard1) do
+              expect(the_log).to eql %w(guard1)
+              fiber_defer(guard2) do
+                expect(the_log).to eql %w(guard1 guard1 guard2)
+              end
+              expect(the_log).to eql %w(guard1 guard1 guard2 guard1 guard2)
+              EM.stop
+            end
+          end
+        end
+      end
+    end
+    context 'when a hash guard is provided' do
+      before(:each) do
+        Thread.current[:a] = 1
+        Thread.current[:b] = 2
+      end
+      after(:each) do
+        Thread.current[:a] = nil
+        Thread.current[:b] = nil
+      end
+      it 'propagates the thread/fiber-local variables into the block' do
+        EM.run do
+          with_fiber_defer do
+            Thread.current[:a] = 42
+            guard = { Thread.current[:a] => proc {|x| Thread.current[:a] = x} }
+            fiber_defer(guard) do
+              expect(Thread.current[:a]).to eql 42
+            end
+            expect(Thread.current[:a]).to eql 42
+            EM.stop
+          end
+        end
+      end
+      context 'and an inherited guard is provided' do
+        it 'applies the inherited guard and then the local guard upon entering and exiting the block' do
+          EM.run do
+            guard1 = {
+              Thread.current[:a] => proc {|x| Thread.current[:a] = x},
+              Thread.current[:b] => proc {|x| Thread.current[:b] = x}
+            }
+            with_fiber_defer(guard1) do
+              Thread.current[:b] = 22
+              Thread.current[:c] = 33
+              guard2 = {
+                Thread.current[:b] => proc {|x| Thread.current[:b] = x},
+                Thread.current[:c] => proc {|x| Thread.current[:c] = x}
+              }
+              fiber_defer(guard2) do
+                expect(Thread.current[:a]).to eql 1
+                expect(Thread.current[:b]).to eql 22
+                expect(Thread.current[:c]).to eql 33
+              end
+              expect(Thread.current[:a]).to eql 1
+              expect(Thread.current[:b]).to eql 22
+              expect(Thread.current[:c]).to eql 33
+              EM.stop
+            end
+          end
+        end
+      end
+    end
+    context 'when an invalid guard is provided' do
+      it 'raises an error' do
+        EM.run do
+          with_fiber_defer do
+            expect{fiber_defer(3){ }}.to raise_error /guard/
+          end
+          EM.stop
+        end
+      end
+    end
+    it 'cannot be nested in fiber_defer' do
+      EM.run do
+        with_fiber_defer do
+          fiber_defer do
+            expect{fiber_defer{}}.to raise_error /nested/
+          end
+          EM.stop
+        end
+      end
+    end
   end
 
   describe '#mongoid_fiber_defer' do
@@ -130,4 +284,5 @@ describe Abstractivator::FiberDefer do
       end
     end
   end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractivator
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Peter Winton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-30 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler