exceptional_synchrony 1.0.1 → 1.3.0

data/lib/exceptional_synchrony.rb

@@ -1,4 +1,3 @@
-require 'hobo_support'
 require 'em-synchrony'
 require 'em-synchrony/em-http'
 require 'exception_handling'

data/lib/exceptional_synchrony/callback_exceptions.rb

@@ -21,13 +21,13 @@ module ExceptionalSynchrony
             result
           end
         when :failed
-          if result.respond_to?(:error) && result.error =~ /timeout/i
-            raise Timeout::Error
+          if result.respond_to?(:error)
+             handle_result_error(result)
           else
-            raise Failure, result.inspect
+            raise_failure_for_result(result)
           end
         else
-          raise ArgumentError, "No deferred status set yet: #{deferred_status.inspect} #{result.inspect}"
+          raise ArgumentError, "No deferred status set yet: #{deferred_status.inspect} #{truncated_inspect(result)}"
         end
       end
 
@@ -38,6 +38,38 @@ module ExceptionalSynchrony
           ex
         end
       end
+
+      private
+
+      def handle_result_error(result)
+        error = result.error
+        if error_is_a_timeout?(error)
+          raise Timeout::Error
+        else
+          raise_failure_for_result(result, error: error)
+        end
+      end
+
+      def raise_failure_for_result(result, error: nil)
+        result_string = truncated_inspect(result)
+        error_string = if error
+                         "ERROR = #{truncated_inspect(error)}; "
+                       end
+        raise Failure,  "#{error_string}RESULT = #{result_string}"
+      end
+
+      def truncated_inspect(obj)
+        inspection = obj.inspect[0, 101]
+        if inspection.length > 100
+          inspection[0, 92] + '...TRUNC'
+        else
+          inspection
+        end
+      end
+
+      def error_is_a_timeout?(error)
+        error =~ /timeout/i || error == Errno::ETIMEDOUT
+      end
     end
   end
 end

data/lib/exceptional_synchrony/event_machine_proxy.rb

@@ -5,6 +5,10 @@ require 'em-http'
 require 'em-synchrony/em-http'
 
 module ExceptionalSynchrony
+  # It is important for this exception to be inherited from Exception so that
+  # when thrown it does not get caught by the EventMachine.error_handler.
+  class FatalRunError < Exception; end
+
   class EventMachineProxy
 
     attr_reader :connection
@@ -41,6 +45,12 @@ module ExceptionalSynchrony
       @synchrony.sleep(seconds)
     end
 
+    def yield_to_reactor
+      if reactor_running?
+        @synchrony.sleep(0)
+      end
+    end
+
     def next_tick(&block)
       @synchrony.next_tick do
         ensure_completely_safe("next_tick") do
@@ -54,17 +64,39 @@ module ExceptionalSynchrony
       @proxy_class.next_tick { } #Fake out EventMachine's epoll mechanism so we don't block until timers fire
     end
 
+    def defers_finished?
+      @proxy_class.defers_finished?
+    end
+
     def connect(server, port = nil, handler = nil, *args, &block)
       @proxy_class.connect(server, port, handler, *args, &block)
     end
 
-    def run(&block)
-      ensure_completely_safe("run") do
-        if @proxy_class.respond_to?(:synchrony)
-          @proxy_class.synchrony(&block)
-        else
-          @proxy_class.run(&block)
-        end
+    # The on_error option has these possible values:
+    #   :log   - log any rescued StandardError exceptions and continue
+    #   :raise - raise FatalRunError for any rescued StandardError exceptions
+    def run(on_error: :log, &block)
+      case on_error
+      when :log   then run_with_error_logging(&block)
+      when :raise then run_with_error_raising(&block)
+      else raise ArgumentError, "Invalid on_error: #{on_error.inspect}, must be :log or :raise"
+      end
+    end
+
+    # This method will execute the block on the background thread pool
+    # By default, it will block the caller until the background thread has finished, so that the result can be returned
+    #  :wait_for_result - setting this to false will prevent the caller from being blocked by this deferred work
+    def defer(context, wait_for_result: true, &block)
+      if wait_for_result
+        deferrable = EventMachine::DefaultDeferrable.new
+        callback = -> (result) { deferrable.succeed(result) }
+
+        EventMachine.defer(nil, callback) { CallbackExceptions.return_exception(&block) }
+        EventMachine::Synchrony.sync(deferrable)
+        CallbackExceptions.map_deferred_result(deferrable)
+      else
+        EventMachine.defer { ExceptionHandling.ensure_completely_safe("defer", &block) }
+        nil
       end
     end
 
@@ -90,6 +122,38 @@ module ExceptionalSynchrony
         yield
       end
     end
+
+    def rescue_exceptions_and_ensure_exit(context)
+      yield
+    rescue StandardError => ex
+      # Raise a non-StandardError so that not caught by EM.error_handler.
+      # Expecting rescued exception to be stored in this new exception's cause.
+      raise FatalRunError, "Fatal EventMachine #{context} error\n#{ex.class.name}: #{ex.message}"
+    end
+
+    private
+
+    def run_with_error_logging(&block)
+      ensure_completely_safe("run_with_error_logging") do
+        if @proxy_class.respond_to?(:synchrony)
+          @proxy_class.synchrony(&block)
+        else
+          @proxy_class.run(&block)
+        end
+      end
+    end
+
+    def run_with_error_raising(&block)
+      run_block = -> { rescue_exceptions_and_ensure_exit("run_with_error_raising", &block) }
+
+      rescue_exceptions_and_ensure_exit("run_with_error_raising") do
+        if @proxy_class.respond_to?(:synchrony)
+          @proxy_class.synchrony(&run_block)
+        else
+          @proxy_class.run(&run_block)
+        end
+      end
+    end
   end
 
   EMP = EventMachineProxy.new(EventMachine, EventMachine::HttpRequest)

data/lib/exceptional_synchrony/limited_work_queue.rb

@@ -1,15 +1,17 @@
 module ExceptionalSynchrony
   class LimitedWorkQueue
+
     def initialize(em, limit)
       @em = em
       limit > 0 or raise ArgumentError, "limit must be positive"
       @limit = limit
       @worker_count = 0
       @job_procs = []
+      @paused = false
     end
 
     # Adds a job_proc to work.
-    def add(proc = nil, &block)
+    def add!(proc = nil, &block)
       job = proc || block
       job.respond_to?(:call) or raise "Must respond_to?(:call)! #{job.inspect}"
       if @job_procs.any? && job.respond_to?(:merge) && (merged_queue = job.merge(@job_procs))
@@ -17,8 +19,9 @@ module ExceptionalSynchrony
       else
         @job_procs << job
       end
-      work!
+      work! unless paused?
     end
+    alias_method :add, :add!
 
     def workers_empty?
       @worker_count.zero?
@@ -32,18 +35,39 @@ module ExceptionalSynchrony
       @job_procs.empty?
     end
 
-    private
+    def paused?
+      @paused
+    end
+
+    def pause!
+      @paused = true
+    end
+
+    def unpause!
+      @paused = false
+    end
+
+    def items
+      @job_procs
+    end
+
     def work!
       until queue_empty? || workers_full?
         job_proc = @job_procs.shift
         @worker_count += 1
         Fiber.new do
-          job_proc.call
-          worker_done
+          begin
+            job_proc.call
+          rescue => ex
+            ExceptionHandling.log_error(ex, "LimitedWorkQueue encountered an exception")
+          ensure
+            worker_done
+          end
         end.resume
       end
     end
 
+    private
     def worker_done
       @worker_count -= 1
       work!

data/lib/exceptional_synchrony/parallel_sync.rb

@@ -1,5 +1,6 @@
 require 'fiber'
 require 'set'
+require 'invoca/utils/hash'
 
 module ExceptionalSynchrony
   class ParallelSync

data/lib/exceptional_synchrony/version.rb

@@ -1,3 +1,3 @@
 module ExceptionalSynchrony
-  VERSION = '1.0.1'
+  VERSION = '1.3.0'
 end

data/test/test_helper.rb

@@ -1,11 +1,23 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'bundler'
+Bundler.setup(:default, :development)
+
 require_relative '../lib/exceptional_synchrony.rb'
 
 require 'minitest/autorun' or raise "Already loaded minitest?"
 require 'minitest/pride'
+require 'minitest/reporters'
+Minitest::Reporters.use! [
+  Minitest::Reporters::DefaultReporter.new,
+  Minitest::Reporters::JUnitReporter.new
+]
 require 'webmock'
 require 'webmock/minitest'
 require 'rr'
 
+ActiveSupport::TestCase.test_order = :sorted
+
 module TestHelper
   @@constant_overrides = []
 

data/test/unit/callback_exceptions_test.rb

@@ -1,4 +1,5 @@
 require_relative '../test_helper'
+require 'pry'
 
 describe ExceptionalSynchrony::CallbackExceptions do
   describe "ensure_callback" do
@@ -60,14 +61,14 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable = EM::DefaultDeferrable.new
         deferrable.succeed(12)
         result = ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        result.must_equal 12
+        expect(result).must_equal(12)
       end
 
       it "should map success values to an array" do
         deferrable = EM::DefaultDeferrable.new
         deferrable.succeed(12, 13, 14)
         result = ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        result.must_equal [12, 13, 14]
+        expect(result).must_equal([12, 13, 14])
       end
 
       it "should map success exception values to raise" do
@@ -77,7 +78,7 @@ describe ExceptionalSynchrony::CallbackExceptions do
         result = assert_raises(ArgumentError) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
-        result.must_equal exception
+        expect(result).must_equal(exception)
       end
     end
 
@@ -87,8 +88,18 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable.fail(first: "a", last: "b")
         result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        end
-        result.message.must_equal "{:first=>\"a\", :last=>\"b\"}"
+        end.message
+        expect(result).must_equal("RESULT = {:first=>\"a\", :last=>\"b\"}")
+      end
+
+      it "should truncate long failures" do
+        deferrable = EM::DefaultDeferrable.new
+        deferrable.fail('a'*75 + 'b'*75)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end.message
+        expected_message = "RESULT = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb...TRUNC"
+        expect(result).must_equal(expected_message)
       end
 
       it "should map failure exceptions to raise" do
@@ -97,9 +108,9 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable.fail(exception)
         result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        end
-        result.message.must_match /ArgumentError/
-        result.message.must_match /Wrong argument!/
+        end.message
+        expect(result).must_match(/ArgumentError/)
+        expect(result).must_match(/Wrong argument!/)
       end
 
       it "should map timeout failure to raise TimeoutError" do
@@ -114,6 +125,47 @@ describe ExceptionalSynchrony::CallbackExceptions do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
       end
+
+      it "should map Errno::ETIMEDOUT to TimeoutError" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          Errno::ETIMEDOUT
+        end
+
+        deferrable.fail(deferrable)
+        assert_raises(Timeout::Error) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+      end
+
+      it "should map other SystemCallError exceptions to Failures with the error in the message" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          Errno::ECONNREFUSED
+        end
+
+        deferrable.fail(deferrable)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        expect(result.message).must_match(/\AERROR = Errno::ECONNREFUSED; RESULT = #<EventMachine::DefaultDeferrable/)
+      end
+
+      it "should map any other errors to Failure with the error in the message" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          ArgumentError.new("Some errror")
+        end
+
+        deferrable.fail(deferrable)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        expect(result.message).must_match(/\AERROR = #<ArgumentError: Some errror>; RESULT = #<EventMachine::DefaultDeferrable/)
+      end
     end
 
     describe "no status" do
@@ -122,29 +174,29 @@ describe ExceptionalSynchrony::CallbackExceptions do
         result = assert_raises(ArgumentError) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
-        result.message.must_match /no deferred status set yet/i
+        expect(result.message).must_match(/no deferred status set yet/i)
       end
     end
   end
 
   describe "return_exception" do
     it "should return the value if no exception" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception do
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception do
         14
-      end.must_equal 14
+      end).must_equal(14)
     end
 
     it "should yield its args" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception(0, 1) do |a, b|
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception(0, 1) do |a, b|
         assert_equal [0, 1], [a, b]
         14
-      end.must_equal 14
+      end).must_equal(14)
     end
 
     it "should rescue any exception that was raised and return it" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception do
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception do
         raise ArgumentError, "An argument error occurred"
-      end.inspect.must_equal ArgumentError.new("An argument error occurred").inspect
+      end.inspect).must_equal(ArgumentError.new("An argument error occurred").inspect)
     end
   end
 end

data/test/unit/event_machine_proxy_test.rb

@@ -3,10 +3,39 @@ require_relative '../test_helper'
 describe ExceptionalSynchrony::EventMachineProxy do
   include TestHelper
 
+  class RunProxyMock
+    class << self
+      def run(&block)
+        block.call
+        :run
+      end
+
+      def error_handler
+      end
+    end
+  end
+
+  class SynchronyProxyMock < RunProxyMock
+    class << self
+      def synchrony(&block)
+        block.call
+        :synchrony
+      end
+    end
+  end
+
+  def stop_em_after_defers_finish!(em)
+    check_finished_counter = 0
+    em.add_periodic_timer(0.1) do
+      (check_finished_counter += 1) > 20 and raise "defer never finished!"
+      em.defers_finished? and em.stop
+    end
+  end
+
   before do
     @em = ExceptionalSynchrony::EventMachineProxy.new(EventMachine, nil)
     @yielded_value = nil
-    @block = lambda { |value| @yielded_value = value }
+    @block = -> (value) { @yielded_value = value }
   end
 
   it "should proxy add_timer" do
@@ -39,7 +68,68 @@ describe ExceptionalSynchrony::EventMachineProxy do
     ServerClass = Class.new
     mock(EventMachine).connect(ServerClass, 8080, :handler, :extra_arg).yields(:called)
     @em.connect(ServerClass, 8080, :handler, :extra_arg, &@block)
-    @yielded_value.must_equal :called
+    expect(@yielded_value).must_equal(:called)
+  end
+
+  describe "#yield_to_reactor" do
+    it "should give control to other threads when the reactor is running" do
+      mock(@em).reactor_running? { true }
+      mock(EventMachine::Synchrony).sleep(0)
+      @em.yield_to_reactor
+    end
+
+    it "should be a no-op if the reactor is not running" do
+      mock(@em).reactor_running? { false }
+      stub(EventMachine::Synchrony).sleep(0) { raise "Should not sleep!" }
+      @em.yield_to_reactor
+    end
+  end
+
+  describe "#defer" do
+    before do
+      logger = Logger.new(STDERR)
+      logger.extend ContextualLogger::LoggerMixin
+      ExceptionHandling.logger = logger
+    end
+
+    it "should output its block's output when it doesn't raise an error, by default" do
+      @em.run do
+        assert_equal 12, @em.defer("#defer success") { 12 }
+        @em.stop
+      end
+    end
+
+    it "should not wait for its block to run if option is passed" do
+      @block_ran = false
+
+      @em.run do
+        assert_nil @em.defer("#defer success", wait_for_result: false) { @block_ran = true; 12 }
+        refute @block_ran
+        stop_em_after_defers_finish!(@em)
+      end
+
+      assert @block_ran
+    end
+
+    it "should handle exceptions when not waiting for its block to run" do
+      mock(ExceptionHandling).log_error(is_a(RuntimeError), "defer", {})
+
+      @em.run do
+        assert_nil @em.defer("#defer success", wait_for_result: false) { raise RuntimeError, "error in defer" }
+        stop_em_after_defers_finish!(@em)
+      end
+    end
+
+    it "should raise an error when its block raises an error" do
+      @em.run do
+        ex = assert_raises(ArgumentError) do
+          @em.defer("#defer raising an error") { raise ArgumentError, "!!!" }
+        end
+
+        assert_equal "!!!", ex.message
+        @em.stop
+      end
+    end
   end
 
   EXCEPTION = ArgumentError.new('in block')
@@ -50,45 +140,68 @@ describe ExceptionalSynchrony::EventMachineProxy do
     end
 
     it "add_timer" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "add_timer")
+      mock(ExceptionHandling).log_error(EXCEPTION, "add_timer", {})
       mock(EventMachine::Synchrony).add_timer(10) { |duration, *args| args.first.call }
       @em.add_timer(10) { raise EXCEPTION }
     end
 
     it "add_periodic_timer" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "add_periodic_timer")
+      mock(ExceptionHandling).log_error(EXCEPTION, "add_periodic_timer", {})
       mock(EventMachine::Synchrony).add_periodic_timer(10) { |duration, *args| args.first.call }
       @em.add_periodic_timer(10) { raise EXCEPTION }
     end
 
     it "next_tick" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "next_tick")
+      mock(ExceptionHandling).log_error(EXCEPTION, "next_tick", {})
       mock(EventMachine::Synchrony).next_tick { |*args| args.first.call }
       @em.next_tick { raise EXCEPTION }
     end
   end
 
-  [false, true].each do |synchrony|
-    describe "synchrony = #{synchrony}" do
-      it "should dispatch to the proxy's synchrony method instead of run iff synchrony" do
-        proxy_mock = Struct.new(:proxy, :class_connection) do
-          if synchrony
-            def self.synchrony(&block)
-              block.(:synchrony)
+  { synchrony: SynchronyProxyMock, run: RunProxyMock }.each do |method, proxy_mock|
+    describe "run" do
+      before do
+        @proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
+      end
+
+      it "should raise ArgumentError if on_error has invalid value" do
+        assert_raises(ArgumentError, "Invalid on_error: :ignore, must be :log or :raise") do
+          @proxy.run(on_error: :ignore)
+        end
+      end
+
+      describe "without error" do
+        [:log, :raise].each do |on_error|
+          describe "when using #{method} and on_error = #{on_error}" do
+            it "should dispatch to the proxy's synchrony method instead of run iff synchrony" do
+              dispatched = false
+              assert_equal method, (@proxy.run(on_error: on_error) { dispatched = true })
+              assert_equal true, dispatched
             end
           end
+        end
+      end
 
-          def self.run(&block)
-            block.(:run)
-          end
+      describe "with error" do
+        before do
+          set_test_const('ExceptionalSynchrony::EventMachineProxy::WRAP_WITH_ENSURE_COMPLETELY_SAFE', true)
         end
 
-        mock(proxy_mock).error_handler
+        describe "when using #{method} and on_error = :log" do
+          it "should rescue any exceptions and log them" do
+            mock(ExceptionHandling).log_error(EXCEPTION, "run_with_error_logging", {})
 
-        proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
+            @proxy.run(on_error: :log) { raise EXCEPTION }
+          end
+        end
 
-        proxy.run(&@block)
-        @yielded_value.must_equal synchrony ? :synchrony : :run
+        describe "when using #{method} and on_error = :raise" do
+          it "should rescue any exceptions and raise FatalRunError" do
+            assert_raises(ExceptionalSynchrony::FatalRunError, "Fatal EventMachine run error") do
+              @proxy.run(on_error: :raise) { raise EXCEPTION }
+            end
+          end
+        end
       end
     end
   end