eventbox 0.1.0 → 1.0.0

data/lib/eventbox/call_context.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+class Eventbox
+  module CallContext
+    # @private
+    def __answer_queue__
+      @__answer_queue__
+    end
+
+    # @private
+    attr_writer :__answer_queue__
+  end
+
+  class BlockingExternalCallContext
+    include CallContext
+  end
+
+  class ActionCallContext
+    include CallContext
+
+    # @private
+    def initialize(event_loop)
+      answer_queue = Queue.new
+      meth = proc do
+        event_loop.callback_loop(answer_queue, nil, self.class)
+      end
+      @action = event_loop.start_action(meth, self.class, [])
+
+      def answer_queue.gc_stop(object_id)
+        close
+      end
+      ObjectSpace.define_finalizer(self, answer_queue.method(:gc_stop))
+
+      @__answer_queue__ = answer_queue
+    end
+
+    # The action that drives the call context.
+    attr_reader :action
+
+    # Terminate the call context and the driving action.
+    #
+    # The method returns immediately and the corresponding action is terminated asynchonously.
+    def shutdown!
+      @__answer_queue__.close
+    end
+  end
+end

data/lib/eventbox/event_loop.rb

@@ -10,22 +10,40 @@ class Eventbox
   class EventLoop
     def initialize(threadpool, guard_time)
       @threadpool = threadpool
+      @shutdown = false
+      @guard_time = guard_time
+      _init_variables
+    end
+
+    def marshal_dump
+      raise TypeError, "Eventbox objects can't be serialized within event scope" if event_scope?
+      @mutex.synchronize do
+        raise TypeError, "Eventbox objects can't be serialized while actions are running" unless @running_actions.empty?
+        [@threadpool, @shutdown, @guard_time]
+      end
+    end
+
+    def marshal_load(array)
+      @threadpool, @shutdown, @guard_time = array
+      _init_variables
+    end
+
+    def _init_variables
       @running_actions = []
       @running_actions_for_gc = []
       @mutex = Mutex.new
-      @shutdown = false
-      @guard_time_proc = case guard_time
+      @guard_time_proc = case @guard_time
         when NilClass
           nil
         when Numeric
-          guard_time and proc do |dt, name|
-            if dt > guard_time
+          @guard_time and proc do |dt, name|
+            if dt > @guard_time
               ecaller = caller.find{|t| !(t=~/lib\/eventbox(\/|\.rb:)/) }
-              warn "guard time exceeded: #{"%2.3f" % dt} sec (limit is #{guard_time}) in `#{name}' called from `#{ecaller}' - please move blocking tasks to actions"
+              warn "guard time exceeded: #{"%2.3f" % dt} sec (limit is #{@guard_time}) in `#{name}' called from `#{ecaller}' - please move blocking tasks to actions"
             end
           end
         when Proc
-          guard_time
+          @guard_time
         else
           raise ArgumentError, "guard_time should be Numeric, Proc or nil"
       end
@@ -53,6 +71,10 @@ class Eventbox
       nil
     end
 
+    def inspect
+      "#<#{self.class}:#{self.object_id} @threadpool=#{@threadpool.inspect}, @shutdown=#{@shutdown.inspect}, @guard_time=#{@guard_time.inspect}, @running_actions=#{@running_actions.length}>"
+    end
+
     def shutdown(&completion_block)
       send_shutdown
       if event_scope?
@@ -111,28 +133,47 @@ class Eventbox
         @latest_answer_queue = nil
         @latest_call_name = nil
         @mutex.unlock
+        Thread.current.thread_variable_set(:__event_loop__, source_event_loop)
         diff_time = Time.now - start_time
         @guard_time_proc&.call(diff_time, name)
-        Thread.current.thread_variable_set(:__event_loop__, source_event_loop)
       end
       source_event_loop
     end
 
-    def async_call(box, name, args, block, wrapper)
+    def _latest_call_context
+      if @latest_answer_queue
+        ctx = BlockingExternalCallContext.new
+        ctx.__answer_queue__ = @latest_answer_queue
+      end
+      ctx
+    end
+
+    def with_call_context(ctx)
+      orig_context = @latest_answer_queue
+      raise ArgumentError, "invalid argument #{ctx.inspect} instead of Eventbox::CallContext" unless CallContext === ctx
+      @latest_answer_queue = ctx.__answer_queue__
+      yield
+    ensure
+      @latest_answer_queue = orig_context
+    end
+
+    def async_call(box, name, args, kwargs, block, wrapper)
       with_call_frame(name, nil) do |source_event_loop|
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self, name)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self, name)
         block = Sanitizer.sanitize_value(block, source_event_loop, self, name)
-        box.send("__#{name}__", *args, &block)
+        box.send("__#{name}__", *args, **kwargs, &block)
       end
     end
 
-    def sync_call(box, name, args, block, answer_queue, wrapper)
+    def sync_call(box, name, args, kwargs, block, answer_queue, wrapper)
       with_call_frame(name, answer_queue) do |source_event_loop|
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self, name)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self, name)
         block = Sanitizer.sanitize_value(block, source_event_loop, self, name)
-        res = box.send("__#{name}__", *args, &block)
+        res = box.send("__#{name}__", *args, **kwargs, &block)
         res = Sanitizer.sanitize_value(res, self, source_event_loop)
         answer_queue << res
       end
@@ -140,32 +181,34 @@ class Eventbox
 
     def yield_call(box, name, args, kwargs, block, answer_queue, wrapper)
       with_call_frame(name, answer_queue) do |source_event_loop|
-        args << _completion_proc(answer_queue, name, source_event_loop)
-        args << kwargs unless kwargs.empty?
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args << new_completion_proc(answer_queue, name, source_event_loop)
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self, name)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self, name)
         block = Sanitizer.sanitize_value(block, source_event_loop, self, name)
-        box.send("__#{name}__", *args, &block)
+        box.send("__#{name}__", *args, **kwargs, &block)
       end
     end
 
     # Anonymous version of async_call
-    def async_proc_call(pr, args, arg_block, wrapper)
+    def async_proc_call(pr, args, kwargs, arg_block, wrapper)
       with_call_frame(AsyncProc, nil) do |source_event_loop|
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self)
         arg_block = Sanitizer.sanitize_value(arg_block, source_event_loop, self)
-        pr.yield(*args, &arg_block)
+        pr.yield(*args, **kwargs, &arg_block)
       end
     end
 
     # Anonymous version of sync_call
-    def sync_proc_call(pr, args, arg_block, answer_queue, wrapper)
+    def sync_proc_call(pr, args, kwargs, arg_block, answer_queue, wrapper)
       with_call_frame(SyncProc, answer_queue) do |source_event_loop|
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self)
         arg_block = Sanitizer.sanitize_value(arg_block, source_event_loop, self)
-        res = pr.yield(*args, &arg_block)
+        res = pr.yield(*args, **kwargs, &arg_block)
         res = Sanitizer.sanitize_value(res, self, source_event_loop)
         answer_queue << res
       end
@@ -174,18 +217,20 @@ class Eventbox
     # Anonymous version of yield_call
     def yield_proc_call(pr, args, kwargs, arg_block, answer_queue, wrapper)
       with_call_frame(YieldProc, answer_queue) do |source_event_loop|
-        args << _completion_proc(answer_queue, pr, source_event_loop)
-        args << kwargs unless kwargs.empty?
-        args = wrapper.call(source_event_loop, *args) if wrapper
+        args << new_completion_proc(answer_queue, pr, source_event_loop)
+        args, kwargs = wrapper.call(source_event_loop, self, *args, **kwargs) if wrapper
         args = Sanitizer.sanitize_values(args, source_event_loop, self)
+        kwargs = Sanitizer.sanitize_kwargs(kwargs, source_event_loop, self)
         arg_block = Sanitizer.sanitize_value(arg_block, source_event_loop, self)
-        pr.yield(*args, &arg_block)
+        pr.yield(*args, **kwargs, &arg_block)
       end
     end
 
-    # Called when an external proc finished
-    def external_proc_result(cbresult, res)
-      with_call_frame(ExternalProc, nil) do
+    # Called when an external object call finished
+    def external_call_result(cbresult, res, answer_queue, wrapper)
+      with_call_frame(ExternalObject, answer_queue) do |source_event_loop|
+        res, _ = wrapper.call(source_event_loop, self, res) if wrapper
+        res = Sanitizer.sanitize_value(res, source_event_loop, self)
         cbresult.yield(*res)
       end
     end
@@ -193,13 +238,13 @@ class Eventbox
     def new_async_proc(name=nil, klass=AsyncProc, &block)
       raise InvalidAccess, "async_proc outside of the event scope is not allowed" unless event_scope?
       wrapper = ArgumentWrapper.build(block, "async_proc #{name}")
-      pr = klass.new do |*args, &arg_block|
+      pr = klass.new do |*args, **kwargs, &arg_block|
         if event_scope?
           # called in the event scope
-          block.yield(*args, &arg_block)
+          block.yield(*args, **kwargs, &arg_block)
         else
           # called externally
-          async_proc_call(block, args, arg_block, wrapper)
+          async_proc_call(block, args, kwargs, arg_block, wrapper)
         end
         pr
       end
@@ -208,15 +253,15 @@ class Eventbox
     def new_sync_proc(name=nil, &block)
       raise InvalidAccess, "sync_proc outside of the event scope is not allowed" unless event_scope?
       wrapper = ArgumentWrapper.build(block, "sync_proc #{name}")
-      SyncProc.new do |*args, &arg_block|
+      SyncProc.new do |*args, **kwargs, &arg_block|
         if event_scope?
           # called in the event scope
-          block.yield(*args, &arg_block)
+          block.yield(*args, **kwargs, &arg_block)
         else
           # called externally
           answer_queue = Queue.new
-          sel = sync_proc_call(block, args, arg_block, answer_queue, wrapper)
-          callback_loop(answer_queue, sel)
+          sel = sync_proc_call(block, args, kwargs, arg_block, answer_queue, wrapper)
+          callback_loop(answer_queue, sel, block)
         end
       end
     end
@@ -227,20 +272,19 @@ class Eventbox
       YieldProc.new do |*args, **kwargs, &arg_block|
         if event_scope?
           # called in the event scope
-          safe_yield_result(args, block)
-          args << kwargs unless kwargs.empty?
-          block.yield(*args, &arg_block)
+          internal_yield_result(args, block)
+          block.yield(*args, **kwargs, &arg_block)
           nil
         else
           # called externally
           answer_queue = Queue.new
           sel = yield_proc_call(block, args, kwargs, arg_block, answer_queue, wrapper)
-          callback_loop(answer_queue, sel)
+          callback_loop(answer_queue, sel, block)
         end
       end
     end
 
-    def safe_yield_result(args, name)
+    def internal_yield_result(args, name)
       complete = args.last
       unless Proc === complete
         if Proc === name
@@ -252,9 +296,9 @@ class Eventbox
       args[-1] = proc do |*cargs, &cblock|
         unless complete
           if Proc === name
-            raise MultipleResults, "received multiple results for #{name.inspect}"
+            raise MultipleResults, "second result yielded for #{name.inspect} that already returned"
           else
-            raise MultipleResults, "received multiple results for method `#{name}'"
+            raise MultipleResults, "second result yielded for method `#{name}' that already returned"
           end
         end
         res = complete.yield(*cargs, &cblock)
@@ -263,13 +307,15 @@ class Eventbox
       end
     end
 
-    private def _completion_proc(answer_queue, name, source_event_loop)
-      new_async_proc(name, CompletionProc) do |*resu|
+    private def new_completion_proc(answer_queue, name, source_event_loop)
+      pr = new_async_proc(name, CompletionProc) do |*resu|
         unless answer_queue
+          # It could happen, that two threads call the CompletionProc simultanously so that nothing is raised here.
+          # In this case the failure is caught in callback_loop instead, but in all other cases the failure is raised early here at the caller side.
           if Proc === name
-            raise MultipleResults, "received multiple results for #{name.inspect}"
+            raise MultipleResults, "second result yielded for #{name.inspect} that already returned"
           else
-            raise MultipleResults, "received multiple results for method `#{name}'"
+            raise MultipleResults, "second result yielded for method `#{name}' that already returned"
           end
         end
         resu = Sanitizer.sanitize_values(resu, self, source_event_loop)
@@ -277,29 +323,51 @@ class Eventbox
         answer_queue << resu
         answer_queue = nil
       end
+      pr.__answer_queue__ = answer_queue
+      pr
     end
 
-    def callback_loop(answer_queue, source_event_loop)
+    def callback_loop(answer_queue, source_event_loop, name)
       loop do
         rets = answer_queue.deq
         case rets
-        when Callback
-          cbres = rets.block.yield(*rets.args, &rets.arg_block)
+        when ExternalObjectCall
+          cbres = rets.object.send(rets.method, *rets.args, **rets.kwargs, &rets.arg_block)
 
           if rets.cbresult
-            cbres = Sanitizer.sanitize_value(cbres, source_event_loop, self)
-            external_proc_result(rets.cbresult, cbres)
+            external_call_result(rets.cbresult, cbres, answer_queue, rets.result_wrapper)
           end
         when WrappedException
-          answer_queue.close if answer_queue.respond_to?(:close)
+          close_answer_queue(answer_queue, name)
           raise(*rets.exc)
         else
-          answer_queue.close if answer_queue.respond_to?(:close)
+          close_answer_queue(answer_queue, name)
           return rets
         end
       end
     end
 
+    private def close_answer_queue(answer_queue, name)
+      answer_queue.close
+      unless answer_queue.empty?
+        rets = answer_queue.deq
+        case rets
+        when ExternalObjectCall
+          if Proc === name
+            raise InvalidAccess, "#{rets.objtype} can't be called through #{name.inspect}, since it already returned"
+          else
+            raise InvalidAccess, "#{rets.objtype} can't be called through method `#{name}', since it already returned"
+          end
+        else
+          if Proc === name
+            raise MultipleResults, "second result yielded for #{name.inspect} that already returned"
+          else
+            raise MultipleResults, "second result yielded for method `#{name}' that already returned"
+          end
+        end
+      end
+    end
+
     # Mark an object as to be shared instead of copied.
     def shared_object(object)
       if event_scope?
@@ -310,6 +378,11 @@ class Eventbox
       object
     end
 
+    # Wrap an object as ExternalObject.
+    def €(object)
+      Sanitizer.wrap_object(object, nil, self, nil)
+    end
+
     def thread_finished(action)
       @mutex.synchronize do
         @running_actions.delete(action) or raise(ArgumentError, "unknown action has finished: #{action}")
@@ -317,20 +390,40 @@ class Eventbox
       end
     end
 
-    Callback = Struct.new :block, :args, :arg_block, :cbresult
+    class ExternalObjectCall < Struct.new :object, :method, :args, :kwargs, :arg_block, :cbresult, :result_wrapper
+      def proc?
+        Proc === object
+      end
 
-    def _external_proc_call(block, name, args, arg_block, cbresult, source_event_loop)
-      if @latest_answer_queue
-        args = Sanitizer.sanitize_values(args, self, source_event_loop)
-        arg_block = Sanitizer.sanitize_value(arg_block, self, source_event_loop)
-        @latest_answer_queue << Callback.new(block, args, arg_block, cbresult)
-        nil
+      def objtype
+        proc? ? "closure" : "method `#{method}'"
+      end
+    end
+
+    def _external_object_call(object, method, name, args, kwargs, arg_block, cbresult, source_event_loop, call_context)
+      result_wrapper = ArgumentWrapper.build(cbresult, name) if cbresult
+      args = Sanitizer.sanitize_values(args, self, source_event_loop)
+      kwargs = Sanitizer.sanitize_kwargs(kwargs, self, source_event_loop)
+      arg_block = Sanitizer.sanitize_value(arg_block, self, source_event_loop)
+      cb = ExternalObjectCall.new(object, method, args, kwargs, arg_block, cbresult, result_wrapper)
+
+      if call_context
+        # explicit call_context given
+        if call_context.__answer_queue__.closed?
+          raise InvalidAccess, "#{cb.objtype} #{"defined by `#{name}' " if name}was called with a call context that already returned"
+        end
+        call_context.__answer_queue__ << cb
+      elsif @latest_answer_queue
+        # proc called by a sync or yield call/proc context
+        @latest_answer_queue << cb
       else
-        raise(InvalidAccess, "closure #{"defined by `#{name}' " if name}was yielded by `#{@latest_call_name}', which must a sync_call, yield_call, sync_proc or yield_proc")
+        raise InvalidAccess, "#{cb.objtype} #{"defined by `#{name}' " if name}was called by `#{@latest_call_name}', which must a sync_call, yield_call, sync_proc or yield_proc"
       end
+
+      nil
     end
 
-    def start_action(meth, name, args)
+    def start_action(meth, name, args, &block)
       # Actions might not be tagged to a calling event scope
       source_event_loop = Thread.current.thread_variable_get(:__event_loop__)
       Thread.current.thread_variable_set(:__event_loop__, nil)
@@ -339,23 +432,27 @@ class Eventbox
 
       new_thread = Thread.handle_interrupt(Exception => :never) do
         @threadpool.new do
+          ac = nil
           begin
             Thread.handle_interrupt(AbortAction => :on_blocking) do
               if meth.arity == args.length
-                meth.call(*args)
+                meth.call(*args, &block)
               else
-                meth.call(*args, qu.deq)
+                ac ||= qu.deq
+                meth.call(*args, ac, &block)
               end
             end
           rescue AbortAction
-            # Do nothing, just exit the action
+            ac ||= qu.deq
+            ac.terminate
           rescue WeakRef::RefError
             # It can happen that the GC already swept the Eventbox instance, before some instance action is in a blocking state.
             # In this case access to the Eventbox instance raises a RefError.
             # Since it's now impossible to execute the action up to a blocking state, abort the action prematurely.
             raise unless @shutdown
           ensure
-            thread_finished(qu.deq)
+            ac ||= qu.deq
+            thread_finished(ac)
           end
         end
       end
@@ -368,8 +465,8 @@ class Eventbox
         _update_action_threads_for_gc
       end
 
-      # Enqueue the action twice (for call and for finish)
-      qu << a << a
+      # Enqueue the action for passing as action parameter
+      qu << a
 
       # @shutdown is set without a lock, so that we need to re-check, if it was set while start_action
       if @shutdown