celluloid 0.12.0 → 0.13.0

data/lib/celluloid/pool_manager.rb

@@ -6,7 +6,8 @@ module Celluloid
   # Don't use this class directly. Instead use MyKlass.pool
   class PoolManager
     include Celluloid
-    trap_exit :crash_handler
+    trap_exit :__crash_handler__
+    finalizer :__shutdown__
 
     def initialize(worker_class, options = {})
       @size = options[:size] || [Celluloid.cores, 2].max
@@ -22,7 +23,7 @@ module Celluloid
       @busy = []
     end
 
-    def finalize
+    def __shutdown__
       terminators = (@idle + @busy).each do |actor|
         begin
           actor.future(:terminate)
@@ -34,13 +35,13 @@ module Celluloid
     end
 
     def _send_(method, *args, &block)
-      worker = __provision_worker
+      worker = __provision_worker__
 
       begin
         worker._send_ method, *args, &block
       rescue DeadActorError # if we get a dead actor out of the pool
         wait :respawn_complete
-        worker = __provision_worker
+        worker = __provision_worker__
         retry
       rescue Exception => ex
         abort ex
@@ -76,12 +77,24 @@ module Celluloid
       _send_ :inspect
     end
 
+    def size
+      @size
+    end
+
+    def busy_size
+      @busy.length
+    end
+
+    def idle_size
+      @idle.length
+    end
+
     # Provision a new worker
-    def __provision_worker
+    def __provision_worker__
       while @idle.empty?
         # Wait for responses from one of the busy workers
         response = exclusive { receive { |msg| msg.is_a?(Response) } }
-        Thread.current[:actor].handle_message(response)
+        Thread.current[:celluloid_actor].handle_message(response)
       end
 
       worker = @idle.shift
@@ -91,7 +104,7 @@ module Celluloid
     end
 
     # Spawn a new worker for every crashed one
-    def crash_handler(actor, reason)
+    def __crash_handler__(actor, reason)
       @busy.delete actor
       @idle.delete actor
       return unless reason
@@ -100,7 +113,7 @@ module Celluloid
       signal :respawn_complete
     end
 
-    def respond_to?(method)
+    def respond_to?(method, include_private = false)
       super || @worker_class.instance_methods.include?(method.to_sym)
     end
 

data/lib/celluloid/proxies/actor_proxy.rb

@@ -1,7 +1,7 @@
 module Celluloid
   # A proxy object returned from Celluloid::Actor.new/new_link which converts
   # the normal Ruby method protocol into an inter-actor message protocol
-  class ActorProxy < AbstractProxy
+  class ActorProxy
     attr_reader :mailbox, :thread
 
     def initialize(actor)
@@ -10,17 +10,24 @@ module Celluloid
       @async_proxy  = AsyncProxy.new(actor)
       @future_proxy = FutureProxy.new(actor)
     end
-
+    
+    # allow querying the real class
+    alias :__class__ :class
+    
     def class
       Actor.call @mailbox, :__send__, :class
     end
 
+    def send(meth, *args, &block)
+      Actor.call @mailbox, :send, meth, *args, &block
+    end
+
     def _send_(meth, *args, &block)
       Actor.call @mailbox, :__send__, meth, *args, &block
     end
 
     def inspect
-      Actor.call @mailbox, :inspect
+      Actor.call(@mailbox, :inspect)
     rescue DeadActorError
       "#<Celluloid::Actor(#{@klass}) dead>"
     end
@@ -90,14 +97,7 @@ module Celluloid
 
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
-      # bang methods are async calls
-      if meth.match(/!$/)
-        unbanged_meth = meth.to_s
-        unbanged_meth.slice!(-1, 1)
-        Actor.async @mailbox, unbanged_meth, *args, &block
-      else
-        Actor.call  @mailbox, meth, *args, &block
-      end
+      Actor.call @mailbox, meth, *args, &block
     end
   end
 end

data/lib/celluloid/proxies/async_proxy.rb

@@ -13,7 +13,11 @@ module Celluloid
 
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
-      Actor.async @mailbox, meth, *args, &block
+      if @mailbox == ::Thread.current[:celluloid_mailbox]
+        Actor.async @mailbox, :__send__, meth, *args, &block
+      else
+        Actor.async @mailbox, meth, *args, &block
+      end
     end
   end
 end

data/lib/celluloid/responses.rb

@@ -18,13 +18,15 @@ module Celluloid
   # Call was aborted due to caller error
   class ErrorResponse < Response
     def value
-      if super.is_a? AbortError
-        # Aborts are caused by caller error, so ensure they capture the
-        # caller's backtrace instead of the receiver's
-        raise super.cause.exception
-      else
-        raise super
+      ex = super
+      ex = ex.cause if ex.is_a? AbortError
+
+      if ex.backtrace
+        ex.backtrace << "(celluloid):0:in `remote procedure call'"
+        ex.backtrace.concat(caller)
       end
+
+      raise ex
     end
   end
 end

data/lib/celluloid/stack_dump.rb

@@ -0,0 +1,94 @@
+module Celluloid
+  class StackDump
+
+    class TaskState < Struct.new(:task_class, :status)
+    end
+
+    class ActorState
+      attr_accessor :subject_id, :subject_class, :name
+      attr_accessor :status, :tasks
+      attr_accessor :backtrace
+    end
+
+    class ThreadState < Struct.new(:thread_id, :backtrace)
+    end
+
+    attr_accessor :actors, :threads
+
+    def initialize
+      @actors  = []
+      @threads = []
+
+      snapshot
+    end
+
+    def snapshot
+      Thread.list.each do |thread|
+        if actor = thread[:celluloid_actor]
+          @actors << snapshot_actor(actor)
+        else
+          @threads << snapshot_thread(thread)
+        end
+      end
+    end
+
+    def snapshot_actor(actor)
+      state = ActorState.new
+      state.subject_id = actor.subject.object_id
+      state.subject_class = actor.subject.class
+
+      tasks = actor.tasks
+      if tasks.empty?
+        state.status = :idle
+      else
+        state.status = :running
+        state.tasks = tasks.collect { |t| TaskState.new(t.class, t.status) }
+      end
+
+      state.backtrace = actor.thread.backtrace if actor.thread
+      state
+    end
+
+    def snapshot_thread(thread)
+      ThreadState.new(thread.object_id, thread.backtrace)
+    end
+
+    def dump(output = STDERR)
+      @actors.each do |actor|
+        string = ""
+        string << "Celluloid::Actor 0x#{actor.subject_id.to_s(16)}: #{actor.subject_class}"
+        string << " [#{actor.name}]" if actor.name
+        string << "\n"
+
+        if actor.status == :idle
+          string << "State: Idle (waiting for messages)\n"
+        else
+          string << "State: Running (executing tasks)\n"
+          string << "Tasks:\n"
+
+          actor.tasks.each_with_index do |task, i|
+            string << "  #{i+1}) #{task.task_class}: #{task.status}\n"
+          end
+        end
+
+        display_backtrace actor.backtrace, string
+        output.print string
+      end
+
+      @threads.each do |thread|
+        string = ""
+        string << "Thread 0x#{thread.thread_id.to_s(16)}:\n"
+        display_backtrace thread.backtrace, string
+        output.print string
+      end
+    end
+
+    def display_backtrace(backtrace, output)
+      if backtrace
+        output << "\t" << backtrace.join("\n\t") << "\n\n"
+      else
+        output << "EMPTY BACKTRACE\n\n"
+      end
+    end
+  end
+end

data/lib/celluloid/supervision_group.rb

@@ -60,7 +60,7 @@ module Celluloid
       @members = []
       @registry = registry || Registry.root
 
-      yield self if block_given?
+      yield current_actor if block_given?
     end
 
     def supervise(klass, *args, &block)
@@ -86,9 +86,11 @@ module Celluloid
       @members.map(&:actor)
     end
 
+    finalizer :finalize
+
     # Terminate the group
     def finalize
-      @members.each(&:terminate)
+      @members.reverse_each(&:terminate)
     end
 
     # Restart a crashed actor
@@ -147,7 +149,7 @@ module Celluloid
 
       def terminate
         @actor.terminate if @actor
-      rescue DeadActorError
+      rescue DeadActorError, MailboxError
       end
     end
   end

data/lib/celluloid/system_events.rb

@@ -51,4 +51,15 @@ module Celluloid
 
   # Request for an actor to terminate
   class TerminationRequest < SystemEvent; end
+
+  # Signal a condition
+  class SignalConditionRequest < SystemEvent
+    def initialize(task, value)
+      @task, @value = task, value
+    end
+
+    def call
+      @task.resume(@value)
+    end
+  end
 end

data/lib/celluloid/tasks/task_fiber.rb

@@ -1,21 +1,27 @@
 module Celluloid
+  class FiberStackError < StandardError; end
+
   # Tasks with a Fiber backend
-  class TaskFiber
+  class TaskFiber < Task
     attr_reader :type, :status
 
     # Run the given block within a task
     def initialize(type)
-      @type   = type
-      @status = :new
+      super
+
+      actor    = Thread.current[:celluloid_actor]
+      mailbox  = Thread.current[:celluloid_mailbox]
+      chain_id = Thread.current[:celluloid_chain_id]
 
-      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
       @fiber = Fiber.new do
         @status = :running
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-        Thread.current[:task]    = self
+        Thread.current[:celluloid_actor]    = actor
+        Thread.current[:celluloid_mailbox]  = mailbox
+        Thread.current[:celluloid_task]     = self
+        Thread.current[:celluloid_chain_id] = chain_id
+
         actor.tasks << self
 
         begin
@@ -43,8 +49,10 @@ module Celluloid
     def resume(value = nil)
       @fiber.resume value
       nil
-    rescue FiberError
-      raise DeadTaskError, "cannot resume a dead task"
+    rescue SystemStackError => ex
+      raise FiberStackError, "#{ex} (please see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
+    rescue FiberError => ex
+      raise DeadTaskError, "cannot resume a dead task (#{ex})"
     end
 
     # Terminate this task

data/lib/celluloid/tasks/task_thread.rb

@@ -1,33 +1,40 @@
 module Celluloid
   # Tasks with a Thread backend
-  class TaskThread
+  class TaskThread < Task
     attr_reader :type, :status
 
     # Run the given block within a task
     def initialize(type)
-      @type   = type
-      @status = :new
+      super
 
       @resume_queue = Queue.new
+      @exception_queue = Queue.new
       @yield_mutex  = Mutex.new
       @yield_cond   = ConditionVariable.new
 
-      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      actor    = Thread.current[:celluloid_actor]
+      mailbox  = Thread.current[:celluloid_mailbox]
+      chain_id = Thread.current[:celluloid_chain_id]
+
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
-      @thread = InternalPool.get do
+      @thread = Celluloid.internal_pool.get do
         begin
-          unless @resume_queue.pop.is_a?(Task::TerminatedError)
-            @status = :running
-            Thread.current[:actor]   = actor
-            Thread.current[:mailbox] = mailbox
-            Thread.current[:task]    = self
-            actor.tasks << self
-
-            yield
-          end
+          ex = @resume_queue.pop
+          raise ex if ex.is_a?(Task::TerminatedError)
+
+          @status = :running
+          Thread.current[:celluloid_actor]    = actor
+          Thread.current[:celluloid_mailbox]  = mailbox
+          Thread.current[:celluloid_task]     = self
+          Thread.current[:celluloid_chain_id] = chain_id
+
+          actor.tasks << self
+          yield
         rescue Task::TerminatedError
           # Task was explicitly terminated
+        rescue Exception => ex
+          @exception_queue << ex
         ensure
           @status = :dead
           actor.tasks.delete self
@@ -55,6 +62,9 @@ module Celluloid
       @yield_mutex.synchronize do
         @resume_queue.push(value)
         @yield_cond.wait(@yield_mutex)
+        while @exception_queue.size > 0
+          raise @exception_queue.pop
+        end
       end
 
       nil

data/lib/celluloid/tasks.rb

@@ -0,0 +1,59 @@
+module Celluloid
+  # Asked to do task-related things outside a task
+  class NotTaskError < StandardError; end
+
+  # Trying to resume a dead task
+  class DeadTaskError < StandardError; end
+
+  # Tasks are interruptable/resumable execution contexts used to run methods
+  class Task
+    class TerminatedError < StandardError; end # kill a running task
+
+    # Obtain the current task
+    def self.current
+      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
+    end
+
+    # Suspend the running task, deferring to the scheduler
+    def self.suspend(status)
+      Task.current.suspend(status)
+    end
+
+    # Create a new task
+    def initialize(type)
+      @type   = type
+      @status = :new
+    end
+  end
+  
+  class TaskSet
+    include Enumerable
+  
+    def initialize
+      @tasks = Set.new
+    end
+  
+    def <<(task)
+      @tasks += [task]
+    end
+  
+    def delete(task)
+      @tasks -= [task]
+    end
+  
+    def each(&blk)
+      @tasks.each &blk
+    end
+  
+    def first
+      @tasks.first
+    end
+    
+    def empty?
+      @tasks.empty?
+    end
+  end
+end
+
+require 'celluloid/tasks/task_fiber'
+require 'celluloid/tasks/task_thread'

data/lib/celluloid/thread_handle.rb

@@ -7,7 +7,7 @@ module Celluloid
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
-      @thread = InternalPool.get do
+      @thread = Celluloid.internal_pool.get do
         begin
           yield
         ensure
@@ -35,5 +35,14 @@ module Celluloid
       @mutex.synchronize { @join.wait(@mutex) if @thread }
       self
     end
+
+    # Obtain the backtrace for this thread
+    def backtrace
+      @thread.backtrace
+    rescue NoMethodError
+      # undefined method `backtrace' for nil:NilClass
+      # Swallow this in case this ThreadHandle was terminated and @thread was
+      # set to nil
+    end
   end
 end

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.12.0'
+  VERSION = '0.13.0'
   def self.version; VERSION; end
 end