celluloid 0.16.0 → 0.17.0

data/lib/celluloid/call/sync.rb

@@ -0,0 +1,70 @@
+module Celluloid
+  class Call
+    # Synchronous calls wait for a response
+    class Sync < Call
+      attr_reader :sender, :task, :chain_id
+
+      def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Internals::CallChain.current_id)
+        super(method, arguments, block)
+        @sender   = sender
+        @task     = task
+        @chain_id = chain_id || Celluloid.uuid
+      end
+
+      def dispatch(obj)
+        Internals::CallChain.current_id = @chain_id
+        result = super(obj)
+        respond Internals::Response::Success.new(self, result)
+      rescue Exception => ex
+        # Exceptions that occur during synchronous calls are reraised in the
+        # context of the sender
+        respond Internals::Response::Error.new(self, ex)
+
+        # Aborting indicates a protocol error on the part of the sender
+        # It should crash the sender, but the exception isn't reraised
+        # Otherwise, it's a bug in this actor and should be reraised
+        raise unless ex.is_a?(AbortError)
+      ensure
+        Internals::CallChain.current_id = nil
+      end
+
+      def cleanup
+        exception = DeadActorError.new("attempted to call a dead actor")
+        respond Internals::Response::Error.new(self, exception)
+      end
+
+      def respond(message)
+        @sender << message
+      end
+
+      def response
+        Celluloid.suspend(:callwait, self)
+      end
+
+      def value
+        response.value
+      end
+
+      def wait
+        while true
+          message = Celluloid.mailbox.receive do |msg|
+            msg.respond_to?(:call) && msg.call == self
+          end
+
+          if message.is_a?(SystemEvent)
+            Thread.current[:celluloid_actor].handle_system_event(message)
+          else
+            # FIXME: add check for receiver block execution
+            if message.respond_to?(:value)
+              # FIXME: disable block execution if on :sender and (exclusive or outside of task)
+              # probably now in Call
+              return message
+            else
+              message.dispatch
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/calls.rb

@@ -4,13 +4,15 @@ module Celluloid
     attr_reader :method, :arguments, :block
 
     def initialize(method, arguments = [], block = nil)
-      @method, @arguments = method, arguments
+      @retry = 0
+      @method = method
+      @arguments = arguments
       if block
         if Celluloid.exclusive?
           # FIXME: nicer exception
-          raise "Cannot execute blocks on sender in exclusive mode"
+          fail "Cannot execute blocks on sender in exclusive mode"
         end
-        @block = BlockProxy.new(self, Celluloid.mailbox, block)
+        @block = Proxy::Block.new(self, Celluloid.mailbox, block)
       else
         @block = nil
       end
@@ -22,130 +24,39 @@ module Celluloid
 
     def dispatch(obj)
       check(obj)
-      _block = @block && @block.to_proc
-      obj.public_send(@method, *@arguments, &_block)
+      _b = @block && @block.to_proc
+      obj.public_send(@method, *@arguments, &_b)
+      #     rescue Celluloid::TimeoutError => ex
+      #       raise ex unless ( @retry += 1 ) <= RETRY_CALL_LIMIT
+      #       puts "retrying"
+      #       Internals::Logger.warn("TimeoutError at Call dispatch. Retrying in #{RETRY_CALL_WAIT} seconds. ( Attempt #{@retry} of #{RETRY_CALL_LIMIT} )")
+      #       sleep RETRY_CALL_WAIT
+      #       retry
     end
 
     def check(obj)
-      raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}" unless obj.respond_to? @method
-
+      # NOTE: don't use respond_to? here
       begin
-        arity = obj.method(@method).arity
+        meth = obj.method(@method)
       rescue NameError
-        return
+        raise NoMethodError, "undefined method `#{@method}' for #<#{obj.class}:0x#{obj.object_id.to_s(16)}>"
       end
 
+      arity = meth.arity
+
       if arity >= 0
-        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{arity})" if @arguments.size != arity
+        fail ArgumentError, "wrong number of arguments (#{@arguments.size} for #{arity})" if @arguments.size != arity
       elsif arity < -1
         mandatory_args = -arity - 1
-        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)" if arguments.size < mandatory_args
+        fail ArgumentError, "wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)" if arguments.size < mandatory_args
       end
     rescue => ex
       raise AbortError.new(ex)
     end
   end
-
-  # Synchronous calls wait for a response
-  class SyncCall < Call
-    attr_reader :sender, :task, :chain_id
-
-    def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = CallChain.current_id)
-      super(method, arguments, block)
-
-      @sender   = sender
-      @task     = task
-      @chain_id = chain_id || Celluloid.uuid
-    end
-
-    def dispatch(obj)
-      CallChain.current_id = @chain_id
-      result = super(obj)
-      respond SuccessResponse.new(self, result)
-    rescue Exception => ex
-      # Exceptions that occur during synchronous calls are reraised in the
-      # context of the sender
-      respond ErrorResponse.new(self, ex)
-
-      # Aborting indicates a protocol error on the part of the sender
-      # It should crash the sender, but the exception isn't reraised
-      # Otherwise, it's a bug in this actor and should be reraised
-      raise unless ex.is_a?(AbortError)
-    ensure
-      CallChain.current_id = nil
-    end
-
-    def cleanup
-      exception = DeadActorError.new("attempted to call a dead actor")
-      respond ErrorResponse.new(self, exception)
-    end
-
-    def respond(message)
-      @sender << message
-    end
-
-    def response
-      Celluloid.suspend(:callwait, self)
-    end
-
-    def value
-      response.value
-    end
-
-    def wait
-      loop do
-        message = Celluloid.mailbox.receive do |msg|
-          msg.respond_to?(:call) and msg.call == self
-        end
-
-        if message.is_a?(SystemEvent)
-          Thread.current[:celluloid_actor].handle_system_event(message)
-        else
-          # FIXME: add check for receiver block execution
-          if message.respond_to?(:value)
-            # FIXME: disable block execution if on :sender and (exclusive or outside of task)
-            # probably now in Call
-            break message
-          else
-            message.dispatch
-          end
-        end
-      end
-    end
-  end
-
-  # Asynchronous calls don't wait for a response
-  class AsyncCall < Call
-
-    def dispatch(obj)
-      CallChain.current_id = Celluloid.uuid
-      super(obj)
-    rescue AbortError => ex
-      # Swallow aborted async calls, as they indicate the sender made a mistake
-      Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
-    ensure
-      CallChain.current_id = nil
-    end
-
-  end
-
-  class BlockCall
-    def initialize(block_proxy, sender, arguments, task = Thread.current[:celluloid_task])
-      @block_proxy = block_proxy
-      @sender = sender
-      @arguments = arguments
-      @task = task
-    end
-    attr_reader :task
-
-    def call
-      @block_proxy.call
-    end
-
-    def dispatch
-      response = @block_proxy.block.call(*@arguments)
-      @sender << BlockResponse.new(self, response)
-    end
-  end
-
 end
+
+require "celluloid/call/sync"
+require "celluloid/call/async"
+require "celluloid/call/block"
+require "celluloid/call/block"

data/lib/celluloid/cell.rb

@@ -33,57 +33,69 @@ module Celluloid
       @actor.handle(Call) do |message|
         invoke(message)
       end
-      @actor.handle(BlockCall) do |message|
+      @actor.handle(Call::Block) do |message|
         task(:invoke_block) { message.dispatch }
       end
-      @actor.handle(BlockResponse, Response) do |message|
+      @actor.handle(Internals::Response::Block, Internals::Response) do |message|
         message.dispatch
       end
 
       @actor.start
-      @proxy = (options[:proxy_class] || CellProxy).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
+      @proxy = (options[:proxy_class] || Proxy::Cell).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
     end
     attr_reader :proxy, :subject
 
+    def self.dispatch
+      proc do |subject|
+        subject[:call].dispatch(subject[:subject])
+        subject[:call] = nil
+        subject[:subject] = nil
+      end
+    end
+
     def invoke(call)
       meth = call.method
-      if meth == :__send__
-        meth = call.arguments.first
-      end
+      meth = call.arguments.first if meth == :__send__
       if @receiver_block_executions && meth
         if @receiver_block_executions.include?(meth.to_sym)
           call.execute_block_on_receiver
         end
       end
 
-      task(:call, meth, :dangerous_suspend => meth == :initialize) {
-        call.dispatch(@subject)
-      }
+      task(:call, meth, {call: call, subject: @subject},
+           dangerous_suspend: meth == :initialize, &Cell.dispatch)
     end
 
-    def task(task_type, method_name = nil, meta = nil, &block)
+    def task(task_type, method_name = nil, subject = nil, meta = nil, &_block)
       meta ||= {}
-      meta.merge!(:method_name => method_name)
+      meta.merge!(method_name: method_name)
       @actor.task(task_type, meta) do
         if @exclusive_methods && method_name && @exclusive_methods.include?(method_name.to_sym)
-          Celluloid.exclusive { yield }
+          Celluloid.exclusive { yield subject }
         else
-          yield
+          yield subject
         end
       end
     end
 
-    # Run the user-defined finalizer, if one is set
-    def shutdown
-      return unless @finalizer && @subject.respond_to?(@finalizer, true)
-
-      task(:finalizer, @finalizer, :dangerous_suspend => true) do
+    def self.shutdown
+      proc do |subject|
         begin
-          @subject.__send__(@finalizer)
+          subject[:subject].__send__(subject[:call])
         rescue => ex
-          Logger.crash("#{@subject.class} finalizer crashed!", ex)
+          Internals::Logger.crash("#{subject[:subject].class} finalizer crashed!", ex)
         end
+        subject[:call] = nil
+        subject[:subject] = nil
       end
     end
+
+    # Run the user-defined finalizer, if one is set
+    def shutdown
+      return unless @finalizer && @subject.respond_to?(@finalizer, true)
+
+      task(:finalizer, @finalizer, {call: @finalizer, subject: @subject},
+           dangerous_suspend: true, &Cell.shutdown)
+    end
   end
 end

data/lib/celluloid/condition.rb

@@ -36,7 +36,7 @@ module Celluloid
 
     # Wait for the given signal and return the associated value
     def wait(timeout = nil)
-      raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
+      fail ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
       if actor = Thread.current[:celluloid_actor]
         task = Task.current
@@ -59,7 +59,7 @@ module Celluloid
 
       result = Celluloid.suspend :condwait, waiter
       timer.cancel if timer
-      raise result if result.is_a? ConditionError
+      fail result if result.is_a? ConditionError
       result
     end
 
@@ -69,7 +69,7 @@ module Celluloid
         if waiter = @waiters.shift
           waiter << SignalConditionRequest.new(waiter.task, value)
         else
-          Logger.with_backtrace(caller(3)) do |logger|
+          Internals::Logger.with_backtrace(caller(3)) do |logger|
             logger.debug("Celluloid::Condition signaled spuriously")
           end
         end

data/lib/celluloid/core_ext.rb

@@ -1,4 +1,4 @@
-require 'celluloid/fiber'
+require "celluloid/fiber"
 
 class Thread
   attr_accessor :uuid_counter, :uuid_limit

data/lib/celluloid/current.rb

@@ -0,0 +1,2 @@
+$CELLULOID_BACKPORTED = false
+require "celluloid/autostart"

data/lib/celluloid/deprecate.rb

@@ -0,0 +1,18 @@
+class Thread
+  def self.mailbox
+    Celluloid.mailbox
+  end
+
+  def self.receive(timeout = nil, &block)
+    Celluloid.receive(timeout, &block)
+  end
+end
+
+# TODO: Remove link to Interal::Logger
+module Celluloid
+  SyncCall = Call::Sync
+  EventedMailbox = Mailbox::Evented
+  InternalPool = Group::Pool
+  TaskThread = Task::Threaded
+  TaskFiber = Task::Fibered
+end

data/lib/celluloid/exceptions.rb

@@ -17,7 +17,7 @@ module Celluloid
 
     def initialize(cause)
       @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
+      super "caused by #{cause.inspect}: #{cause}"
     end
   end
 end

data/lib/celluloid/fiber.rb

@@ -1,6 +1,6 @@
 # Fibers are hard... let's go shopping!
 begin
-  require 'fiber'
+  require "fiber"
 rescue LoadError => ex
   if defined? JRUBY_VERSION
     if RUBY_VERSION < "1.9.2"
@@ -9,9 +9,9 @@ rescue LoadError => ex
 
     # Fibers are broken on JRuby 1.6.5. This works around the issue
     if JRUBY_VERSION[/^1\.6\.5/]
-      require 'jruby'
+      require "jruby"
       org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
-      class org::jruby::ext::fiber::ThreadFiber
+      class org.jruby.ext.fiber::ThreadFiber
         field_accessor :state
       end
 

data/lib/celluloid/future.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require "thread"
 
 module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
@@ -8,9 +8,9 @@ module Celluloid
       return super unless block
 
       future = new
-      Celluloid::ThreadHandle.new(Celluloid.actor_system, :future) do
+      Internals::ThreadHandle.new(Celluloid.actor_system, :future) do
         begin
-          call = SyncCall.new(future, :call, args)
+          call = Call::Sync.new(future, :call, args)
           call.dispatch(block)
         rescue
           # Exceptions in blocks will get raised when the value is retrieved
@@ -67,7 +67,7 @@ module Celluloid
       if result
         result.value
       else
-        raise TimeoutError, "Timed out"
+        fail TimeoutError, "Timed out"
       end
     end
     alias_method :call, :value
@@ -77,7 +77,7 @@ module Celluloid
       result = Result.new(value, self)
 
       @mutex.synchronize do
-        raise "the future has already happened!" if @ready
+        fail "the future has already happened!" if @ready
 
         if @forwards
           @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
@@ -97,7 +97,8 @@ module Celluloid
       attr_reader :future
 
       def initialize(result, future)
-        @result, @future = result, future
+        @result = result
+        @future = future
       end
 
       def value