exceptional_synchrony 1.0.1

data/lib/exceptional_synchrony/parallel_sync.rb

@@ -0,0 +1,86 @@
+require 'fiber'
+require 'set'
+
+module ExceptionalSynchrony
+  class ParallelSync
+    def self.parallel(em, *args)
+      parallel_sync = new(em, *args)
+      yield parallel_sync
+      parallel_sync.run_all!
+    end
+
+    # em is the EventMachine proxy
+    # Downstream is an optional queue.  If provided it will run the job for us.  It must create the Fiber as well.
+    def initialize(em, downstream = nil)
+      @em = em
+      @downstream = downstream
+      @jobs = []
+      @finished = Set.new
+    end
+
+    def add(proc = nil, &block)
+      job = proc || block
+      @jobs << job
+    end
+
+    # Runs all the jobs that have been added.
+    # Returns the hash of responses where the key is their ordinal number, in order.
+    def run_all!
+      original_fiber = Fiber.current
+
+      @responses = (0...@jobs.size).build_hash { |key| [key, nil] } # initialize in sorted order so we don't have to sort later
+
+      @jobs.each_with_index do |job, index|
+        run_and_finish = lambda do |*args|
+          @responses[index] = CallbackExceptions.return_exception(*args, &job)
+          @finished.add(index)
+          check_progress(original_fiber)
+        end
+
+        if @downstream
+          if job.respond_to?(:encapsulate)
+            cancel_proc = -> do
+              @responses[index] = :cancelled
+              @finished.add(index)
+            end
+            @downstream.add(job.encapsulate(cancel: cancel_proc, &run_and_finish))
+          else
+            @downstream.add(&run_and_finish)
+          end
+        else
+          Fiber.new(&run_and_finish).resume
+        end
+      end
+
+      unless finished?
+        @yielded = true
+        Fiber.yield
+      end
+
+      raise_any_exceptions(@responses)
+
+      @responses
+    end
+
+  private
+    def check_progress(original_fiber)
+      if finished? && original_fiber.alive? && original_fiber != Fiber.current && @yielded
+        original_fiber.resume
+      end
+    end
+
+    def finished?
+      @finished.size == @jobs.size
+    end
+
+    def raise_any_exceptions(responses)
+      if (exceptions = responses.values.select { |response| response.is_a?(Exception) }).any?
+        master_exception, *remaining_exceptions = exceptions
+        remaining_exceptions.each do |ex|
+          master_exception.message << "\n====================================\n#{ex.class}: #{ex.to_s}"
+        end
+        raise master_exception
+      end
+    end
+  end
+end

data/lib/exceptional_synchrony/version.rb

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

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require_relative '../lib/exceptional_synchrony.rb'
+
+require 'minitest/autorun' or raise "Already loaded minitest?"
+require 'minitest/pride'
+require 'webmock'
+require 'webmock/minitest'
+require 'rr'
+
+module TestHelper
+  @@constant_overrides = []
+
+  def self.included(base)
+    base.class_eval do
+      before do
+        unless @@constant_overrides.nil? || @@constant_overrides.empty?
+          raise "Uh-oh! constant_overrides left over: #{@@constant_overrides.inspect}"
+        end
+        # TODO:this code doesn't seem to be running. But the after code is. Weird. -Colin
+      end
+
+      after do
+        @@constant_overrides && @@constant_overrides.reverse.each do |parent_module, k, v|
+          ExceptionHandling.ensure_completely_safe "constant cleanup #{k.inspect}, #{parent_module}(#{parent_module.class})::#{v.inspect}(#{v.class})" do
+            silence_warnings do
+              if v == :never_defined
+                parent_module.send(:remove_const, k)
+              else
+                parent_module.const_set(k, v)
+              end
+            end
+          end
+        end
+        @@constant_overrides = []
+
+        WebMock.reset!
+      end
+    end
+  end
+
+  def set_test_const(const_name, value)
+    const_name.is_a?(Symbol) and const_name = const_name.to_s
+    const_name.is_a?(String) or raise "Pass the constant name, not its value!"
+
+    final_parent_module = final_const_name = nil
+    original_value =
+        const_name.split('::').reduce(Object) do |parent_module, nested_const_name|
+          parent_module == :never_defined and raise "You need to set each parent constant earlier! #{nested_const_name}"
+          final_parent_module = parent_module
+          final_const_name    = nested_const_name
+          parent_module.const_get(nested_const_name) rescue :never_defined
+        end
+
+    @@constant_overrides << [final_parent_module, final_const_name, original_value]
+
+    silence_warnings { final_parent_module.const_set(final_const_name, value) }
+  end
+end

data/test/unit/callback_exceptions_test.rb

@@ -0,0 +1,150 @@
+require_relative '../test_helper'
+
+describe ExceptionalSynchrony::CallbackExceptions do
+  describe "ensure_callback" do
+    it "should execute succeed with return value" do
+      deferrable = EM::DefaultDeferrable.new
+      mock(deferrable).succeed(42)
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        42
+      end
+    end
+
+    it "should execute succeed by splatting an array return value" do
+      deferrable = EM::DefaultDeferrable.new
+      mock(deferrable).succeed(41, 42)
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        [41, 42]
+      end
+    end
+
+    it "should execute succeed with a double array when you want to return an array value" do
+      deferrable = EM::DefaultDeferrable.new
+      mock(deferrable).succeed([41, 42])
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        [[41, 42]]
+      end
+    end
+
+    it "should execute succeed with the exception that gets raised" do
+      deferrable = EM::DefaultDeferrable.new
+      exception = ArgumentError.new('Error message')
+      mock(deferrable).succeed(exception)
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        raise exception
+      end
+    end
+
+    it "should execute succeed with the exception that gets raised" do
+      deferrable = EM::DefaultDeferrable.new
+      exception = ArgumentError.new('Error message')
+      mock(deferrable).succeed(exception)
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        raise exception
+      end
+    end
+
+    it "should execute succeed even with a Ruby internal exception (not derived from StandardError)" do
+      deferrable = EM::DefaultDeferrable.new
+      exception = NoMemoryError.new('Error message')
+      mock(deferrable).succeed(exception)
+      ExceptionalSynchrony::CallbackExceptions.ensure_callback(deferrable) do
+        raise exception
+      end
+    end
+  end
+
+  describe "map_deferred_result" do
+    describe "success" do
+      it "should map success value" do
+        deferrable = EM::DefaultDeferrable.new
+        deferrable.succeed(12)
+        result = ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        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]
+      end
+
+      it "should map success exception values to raise" do
+        deferrable = EM::DefaultDeferrable.new
+        exception = ArgumentError.new("Wrong argument!")
+        deferrable.succeed(exception)
+        result = assert_raises(ArgumentError) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        result.must_equal exception
+      end
+    end
+
+    describe "failure" do
+      it "should map failure value to raise" do
+        deferrable = EM::DefaultDeferrable.new
+        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
+
+      it "should map failure exceptions to raise" do
+        deferrable = EM::DefaultDeferrable.new
+        exception = ArgumentError.new("Wrong argument!")
+        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
+
+      it "should map timeout failure to raise TimeoutError" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          "Timeout"
+        end
+
+        deferrable.fail(deferrable)
+        assert_raises(Timeout::Error) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+      end
+    end
+
+    describe "no status" do
+      it "should raise ArgumentError if you try to map when there is no result yet" do
+        deferrable = EM::DefaultDeferrable.new
+        result = assert_raises(ArgumentError) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        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
+        14
+      end.must_equal 14
+    end
+
+    it "should yield its args" do
+      ExceptionalSynchrony::CallbackExceptions.return_exception(0, 1) do |a, b|
+        assert_equal [0, 1], [a, b]
+        14
+      end.must_equal 14
+    end
+
+    it "should rescue any exception that was raised and return it" do
+      ExceptionalSynchrony::CallbackExceptions.return_exception do
+        raise ArgumentError, "An argument error occurred"
+      end.inspect.must_equal ArgumentError.new("An argument error occurred").inspect
+    end
+  end
+end

data/test/unit/event_machine_proxy_test.rb

@@ -0,0 +1,100 @@
+require_relative '../test_helper'
+
+describe ExceptionalSynchrony::EventMachineProxy do
+  include TestHelper
+
+  before do
+    @em = ExceptionalSynchrony::EventMachineProxy.new(EventMachine, nil)
+    @yielded_value = nil
+    @block = lambda { |value| @yielded_value = value }
+  end
+
+  it "should proxy add_timer" do
+    mock(EventMachine::Synchrony).add_timer(10)
+    @em.add_timer(10) { }
+  end
+
+  it "should proxy add_periodic_timer" do
+    mock(EventMachine::Synchrony).add_periodic_timer(10)
+    @em.add_periodic_timer(10) { }
+  end
+
+  it "should proxy sleep" do
+    mock(EventMachine::Synchrony).sleep(0.001)
+    @em.sleep(0.001)
+  end
+
+  it "should proxy next_tick" do
+    mock(EventMachine::Synchrony).next_tick
+    @em.next_tick { }
+  end
+
+  it "should proxy stop" do
+    mock(EventMachine).stop
+    mock(EventMachine).next_tick
+    @em.stop
+  end
+
+  it "should proxy connect" 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
+  end
+
+  EXCEPTION = ArgumentError.new('in block')
+
+  describe "blocks should be wrapped in ensure_completely_safe" do
+    before do
+      set_test_const('ExceptionalSynchrony::EventMachineProxy::WRAP_WITH_ENSURE_COMPLETELY_SAFE', true)
+    end
+
+    it "add_timer" do
+      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(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(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)
+            end
+          end
+
+          def self.run(&block)
+            block.(:run)
+          end
+        end
+
+        mock(proxy_mock).error_handler
+
+        proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
+
+        proxy.run(&@block)
+        @yielded_value.must_equal synchrony ? :synchrony : :run
+      end
+    end
+  end
+
+  it "should proxy reactor_running?" do
+    mock(EventMachine).reactor_running?
+    @em.reactor_running?
+  end
+end

data/test/unit/limited_work_queue_test.rb

@@ -0,0 +1,139 @@
+describe ExceptionalSynchrony::LimitedWorkQueue do
+  before do
+    @em = ExceptionalSynchrony::EventMachineProxy.new(EventMachine, EventMachine::HttpRequest)
+  end
+
+  it "should raise an exception if created with a limit < 1" do
+    assert_raises(ArgumentError) do
+      ExceptionalSynchrony::LimitedWorkQueue.new(@em, 0)
+    end.message.must_match /must be positive/
+
+    assert_raises(ArgumentError) do
+      ExceptionalSynchrony::LimitedWorkQueue.new(@em, -2)
+    end.message.must_match /must be positive/
+  end
+
+  describe "when created" do
+    before do
+      @queue = ExceptionalSynchrony::LimitedWorkQueue.new(@em, 2)
+    end
+
+    it "should run non-blocking jobs immediately" do
+      c = 0
+      ExceptionalSynchrony::EMP.run_and_stop do
+        @queue.add { c+=1 }
+        @queue.add { c+=1 }
+        @queue.add { c+=1 }
+      end
+      assert_equal 3, c
+    end
+
+    class LWQTestProc
+      def initialize(cancel_proc = nil, &block)
+        @cancel_proc = cancel_proc
+        @block = block
+      end
+
+      def call
+        @block.call
+      end
+
+      def cancel
+        @cancel_proc.call
+      end
+    end
+
+    it "should allow objects to be queued instead of Procs" do
+      c = 0
+      ExceptionalSynchrony::EMP.run_and_stop do
+        @queue.add(LWQTestProc.new { c+=1 })
+        @queue.add(LWQTestProc.new { c+=1 })
+        @queue.add(LWQTestProc.new { c+=1 })
+      end
+      assert_equal 3, c
+    end
+
+    class LWQTestProcWithMergeDrop < LWQTestProc
+      def merge(queue)
+        if queue.find { |entry| entry.is_a?(self.class) }
+          self.cancel
+          queue # leave it as is (self is dropped)
+        end
+      end
+    end
+
+    it "shouldn't bother with merge when the queue is empty" do
+      job_proc = LWQTestProc.new { }
+      class << job_proc
+        def merge(queue)
+          raise "merge should not be called!"
+        end
+      end
+
+      ExceptionalSynchrony::EMP.run_and_stop do
+        @queue.add(job_proc)
+      end
+    end
+
+    it "should allow objects to merge themselves into the queue (canceling itself)" do
+      c = 0
+      ExceptionalSynchrony::EMP.run_and_stop do
+        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=1 })
+        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=2 })
+        @queue.add(LWQTestProcWithMergeDrop.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
+        @queue.add(LWQTestProcWithMergeDrop.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged (by canceling self)
+        @em.sleep(0.050)
+      end
+      assert_equal 1+2+8+16, c
+    end
+
+    class LWQTestProcWithMergeReplace < LWQTestProc
+      def merge(queue)
+        if same = queue.find { |entry| entry.is_a?(self.class) }
+          same.cancel
+          queue - [same] + [self]
+        end
+      end
+    end
+
+    it "should allow objects to merge themselves into the queue (canceling/replacing earlier)" do
+      c = 0
+      ExceptionalSynchrony::EMP.run_and_stop do
+        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=1 })
+        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=2 })
+        @queue.add(LWQTestProcWithMergeReplace.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
+        @queue.add(LWQTestProcWithMergeReplace.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged with above (replacing above)
+        @em.sleep(0.050)
+      end
+      assert_equal 1+2+4+32, c
+    end
+
+    it "should run 2 blocking tasks in parallel and only start 3rd when one of the first 2 finishes" do
+      stub_request(:get, "http://www.google.com/").
+          to_return(:status => 200, :body => "1", :headers => {})
+
+      stub_request(:get, "http://www.cnn.com/").
+          to_return(:status => 402, :body => "2", :headers => {})
+
+      stub_request(:get, "http://news.ycombinator.com/").
+          to_return(:status => 200, :body => "3", :headers => {})
+
+      ExceptionalSynchrony::EMP.run_and_stop do
+        c = -1
+        started2 = nil; ended0 = nil; ended1 = nil
+        @queue.add { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.google.com").get; ended0 = c+=1 }
+        @queue.add { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.cnn.com").get; ended1 = c+=1 }
+        @queue.add { started2 = c+=1; ExceptionalSynchrony::EMP.connection.new("http://news.ycombinator.com").get; c+=1 }
+
+        3.times do
+          @em.sleep(0.005)
+          break if c == 5
+        end
+
+        assert_equal 5, c
+
+        assert started2 > ended0 || started2 > ended1, [ended0, ended1, started2].inspect
+      end
+    end
+  end
+end