celluloid 0.16.0 → 0.17.3

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(Celluloid.mailbox, self, block)
       else
         @block = nil
       end
@@ -22,130 +24,38 @@ 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::TaskTimeout => ex
+      #       raise ex unless ( @retry += 1 ) <= RETRY_CALL_LIMIT
+      #       puts "retrying"
+      #       Internals::Logger.warn("TaskTimeout 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"

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.mailbox, @actor.proxy, @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

@@ -1,6 +1,4 @@
 module Celluloid
-  class ConditionError < Celluloid::Error; end
-
   # ConditionVariable-like signaling between tasks and threads
   class Condition
     class Waiter
@@ -21,7 +19,7 @@ module Celluloid
           message = @mailbox.receive(@timeout) do |msg|
             msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
           end
-        rescue TimeoutError
+        rescue TimedOut
           raise ConditionError, "timeout after #{@timeout.inspect} seconds"
         end until message
 
@@ -36,7 +34,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 +57,8 @@ 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)
+      return yield(result) if block_given?
       result
     end
 
@@ -69,7 +68,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/debug.rb

@@ -0,0 +1 @@
+$CELLULOID_DEBUG = true

data/lib/celluloid/deprecate.rb

@@ -0,0 +1,21 @@
+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
+  ActorSystem = Actor::System
+  Task::TerminatedError = TaskTerminated
+  Task::TimeoutError = TaskTimeout
+end

data/lib/celluloid/exceptions.rb

@@ -1,23 +1,29 @@
 module Celluloid
-  # Base class of all Celluloid errors
-  Error = Class.new(StandardError)
-
-  # Don't do Actor-like things outside Actor scope
-  NotActorError = Class.new(Celluloid::Error)
-
-  # Trying to do something to a dead actor
-  DeadActorError = Class.new(Celluloid::Error)
-
-  # A timeout occured before the given request could complete
-  TimeoutError = Class.new(Celluloid::Error)
-
-  # The sender made an error, not the current actor
-  class AbortError < Celluloid::Error
+  class Error < StandardError; end
+  class Interruption < Exception; end
+  class TimedOut < Celluloid::Interruption; end # Distinguished from `Timeout`
+  class StillActive < Celluloid::Error; end
+  class NotActive < Celluloid::Error; end
+  class NotActorError < Celluloid::Error; end # Don't do Actor-like things outside Actor scope
+  class DeadActorError < Celluloid::Error; end # Trying to do something to a dead actor
+  class NotTaskError < Celluloid::Error; end # Asked to do task-related things outside a task
+  class DeadTaskError < Celluloid::Error; end # Trying to resume a dead task
+  class TaskTerminated < Celluloid::Interruption; end # Kill a running task after terminate
+  class TaskTimeout < Celluloid::TimedOut; end # A timeout occured before the given request could complete
+  class ConditionError < Celluloid::Error; end
+  class AbortError < Celluloid::Error # The sender made an error, not the current actor
     attr_reader :cause
-
     def initialize(cause)
       @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
+      super "caused by #{cause.inspect}: #{cause}"
+    end
+  end
+  class ThreadLeak < Celluloid::Error; end
+  module Feature
+    module Requires
+      class RubiniusOrJRuby < Celluloid::Error; end
+      class Rubinius < Celluloid::Error; end
+      class JRuby < Celluloid::Error; end
     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,13 @@ module Celluloid
       return super unless block
 
       future = new
-      Celluloid::ThreadHandle.new(Celluloid.actor_system, :future) do
+      # task = Thread.current[:celluloid_task]
+      # actor = Thread.current[:celluloid_actor]
+      Internals::ThreadHandle.new(Celluloid.actor_system, :future) do
         begin
-          call = SyncCall.new(future, :call, args)
+          # Thread.current[:celluloid_task] = task
+          # Thread.current[:celluloid_actor] = actor
+          call = Call::Sync.new(future, :call, args)
           call.dispatch(block)
         rescue
           # Exceptions in blocks will get raised when the value is retrieved
@@ -21,12 +25,36 @@ module Celluloid
 
     attr_reader :address
 
-    def initialize
+    def initialize(&block)
       @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
       @forwards = nil
+      @cancelled = false
+
+      if block
+        @call = Call::Sync.new(self, :call, args)
+        Celluloid.internal_pool.get do
+          begin
+            @call.dispatch(block)
+          rescue
+            # Exceptions in blocks will get raised when the value is retrieved
+          end
+        end
+      else
+        @call = nil
+      end
+    end
+
+    # Execute the given method in future context
+    def execute(receiver, method, args, block)
+      @mutex.synchronize do
+        fail "already calling" if @call
+        @call = Call::Sync.new(self, method, args, block)
+      end
+
+      receiver << @call
     end
 
     # Check if this future has a value yet
@@ -65,19 +93,20 @@ module Celluloid
       end
 
       if result
-        result.value
+        (result.respond_to?(:value)) ? result.value : result
       else
-        raise TimeoutError, "Timed out"
+        fail TimedOut, "Timed out"
       end
     end
     alias_method :call, :value
 
     # Signal this future with the given result value
     def signal(value)
+      return if @cancelled
       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
@@ -89,6 +118,14 @@ module Celluloid
     end
     alias_method :<<, :signal
 
+    def cancel(error)
+      response = ErrorResponse.new(@call, error)
+      signal response
+      @mutex.synchronize do
+        @cancelled = true
+      end
+    end
+
     # Inspect this Celluloid::Future
     alias_method :inspect, :to_s
 
@@ -97,7 +134,8 @@ module Celluloid
       attr_reader :future
 
       def initialize(result, future)
-        @result, @future = result, future
+        @result = result
+        @future = future
       end
 
       def value

data/lib/celluloid/group/pool.rb

@@ -0,0 +1,125 @@
+require "thread"
+
+module Celluloid
+  class Group
+    class Pool < Group
+      # You do not want to use this. Truly, you do not. There is no scenario when you will.
+      # But. If you somehow do.. `Celluloid.group_class = Celluloid::Group::Pool` and weep.
+
+      attr_accessor :max_idle
+
+      def initialize
+        super
+        @mutex = Mutex.new
+        @idle_threads = []
+        @group  = []
+        @busy_size = 0
+        @idle_size = 0
+
+        # TODO: should really adjust this based on usage
+        @max_idle = 16
+      end
+
+      def idle?
+        busy_size.count == 0
+      end
+
+      def busy?
+        busy_size.count > 0
+      end
+
+      attr_reader :busy_size
+
+      attr_reader :idle_size
+
+      # Get a thread from the pool, running the given block
+      def get(&block)
+        @mutex.synchronize do
+          assert_active
+
+          begin
+            if @idle_threads.empty?
+              thread = create
+            else
+              thread = @idle_threads.pop
+              @idle_size = @idle_threads.length
+            end
+          end until thread.status # handle crashed threads
+
+          thread.busy = true
+          @busy_size += 1
+          thread[:celluloid_queue] << block
+          thread
+        end
+      end
+
+      # Return a thread to the pool
+      def put(thread)
+        @mutex.synchronize do
+          thread.busy = false
+          if idle_size + 1 >= @max_idle
+            thread[:celluloid_queue] << nil
+            @busy_size -= 1
+            @group.delete(thread)
+          else
+            @idle_threads.push thread
+            @busy_size -= 1
+            @idle_size = @idle_threads.length
+            clean_thread_locals(thread)
+          end
+        end
+      end
+
+      def shutdown
+        @running = false
+        @mutex.synchronize do
+          finalize
+          @group.each do |thread|
+            thread[:celluloid_queue] << nil
+          end
+          @group.shift.kill until @group.empty?
+          @idle_threads.clear
+          @busy_size = 0
+          @idle_size = 0
+        end
+      end
+
+      private
+
+      # Create a new thread with an associated queue of procs to run
+      def create
+        queue = Queue.new
+        thread = Thread.new do
+          while proc = queue.pop
+            begin
+              proc.call
+            rescue ::Exception => ex
+              Internals::Logger.crash("thread crashed", ex)
+            ensure
+              put thread
+            end
+          end
+        end
+
+        thread[:celluloid_queue] = queue
+        # @idle_threads << thread
+        @group << thread
+        thread
+      end
+
+      # Clean the thread locals of an incoming thread
+      def clean_thread_locals(thread)
+        thread.keys.each do |key|
+          next if key == :celluloid_queue
+
+          # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
+          thread[key] = nil
+        end
+      end
+
+      def finalize
+        @max_idle = 0
+      end
+    end
+  end
+end