celluloid 0.12.4 → 0.13.0.pre

data/lib/celluloid/method.rb

@@ -1,6 +1,7 @@
 module Celluloid
   # Method handles that route through an actor proxy
   class Method
+
     def initialize(actor, name)
       raise NameError, "undefined method `#{name}'" unless actor.respond_to? name
 
@@ -8,6 +9,10 @@ module Celluloid
       @klass = @actor.class
     end
 
+    def arity
+      @actor._send_(:method, @name).arity
+    end
+
     def call(*args, &block)
       @actor._send_(@name, *args, &block)
     end

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
@@ -89,11 +90,11 @@ module Celluloid
     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
@@ -103,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

data/lib/celluloid/proxies/actor_proxy.rb

@@ -18,6 +18,10 @@ module Celluloid
       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
@@ -93,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,86 @@
+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|
+        output << "Celluloid::Actor 0x#{actor.subject_id.to_s(16)}: #{actor.subject_class}"
+        output << " [#{actor.name}]" if actor.name
+        output << "\n"
+
+        if actor.status == :idle
+          output << "State: Idle (waiting for messages)\n"
+        else
+          output << "State: Running (executing tasks)\n"
+          output << "Tasks:\n"
+
+          actor.tasks.each_with_index do |task, i|
+            output << "  #{i+1}) #{task.task_class}: #{task.status}\n"
+          end
+        end
+
+        display_backtrace actor.backtrace, output
+      end
+
+      @threads.each do |thread|
+        output << "Thread 0x#{thread.thread_id.to_s(16)}:\n"
+        display_backtrace thread.backtrace, output
+      end
+    end
+
+    def display_backtrace(backtrace, output)
+      output << "\t" << backtrace.join("\n\t") << "\n\n"
+    end
+  end
+end

data/lib/celluloid/supervision_group.rb

@@ -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/{task.rb → tasks.rb}

@@ -1,6 +1,3 @@
-require 'celluloid/tasks/task_fiber'
-require 'celluloid/tasks/task_thread'
-
 module Celluloid
   # Asked to do task-related things outside a task
   class NotTaskError < StandardError; end
@@ -9,17 +6,26 @@ module Celluloid
   class DeadTaskError < StandardError; end
 
   # Tasks are interruptable/resumable execution contexts used to run methods
-  module Task
+  class Task
     class TerminatedError < StandardError; end # kill a running task
 
     # Obtain the current task
     def self.current
-      Thread.current[:task] or raise NotTaskError, "not within a task context"
+      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
 end
+
+require 'celluloid/tasks/task_fiber'
+require 'celluloid/tasks/task_thread'

data/lib/celluloid/tasks/task_fiber.rb

@@ -2,22 +2,26 @@ 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

data/lib/celluloid/tasks/task_thread.rb

@@ -1,31 +1,35 @@
 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
       @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.is_a?(Task::TerminatedError)
+          raise ex if ex
+
+          @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
         ensure

data/lib/celluloid/thread_handle.rb

@@ -1,18 +1,13 @@
-require 'forwardable'
-
 module Celluloid
   # An abstraction around threads from the InternalPool which ensures we don't
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
-    extend Forwardable
-    def_delegators :@thread, :backtrace
-
     def initialize
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
-      @thread = InternalPool.get do
+      @thread = Celluloid.internal_pool.get do
         begin
           yield
         ensure
@@ -40,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.4'
+  VERSION = '0.13.0.pre'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -30,11 +30,27 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.greet.should == "Hi, I'm Troy McClure"
   end
 
+  it "supports synchronous calls with blocks" do
+    actor = actor_class.new "Blocky Ralboa"
+
+    block_executed = false
+    actor.run { block_executed = true }
+    block_executed.should be_true
+  end
+
   it "supports synchronous calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
     method.call.should == "Hi, I'm Troy McClure"
   end
 
+  it "supports #arity calls via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.arity.should == 0
+
+    method = actor_class.new("Troy McClure").method(:change_name)
+    method.arity.should == 1
+  end
+
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
@@ -77,75 +93,11 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.respond_to?(:zomg_private, true).should be_true
   end
 
-  it "raises NoMethodError when a nonexistent method is called" do
-    actor = actor_class.new "Billy Bob Thornton"
-
-    expect do
-      actor.the_method_that_wasnt_there
-    end.to raise_exception(NoMethodError)
-  end
-
-  it "reraises exceptions which occur during synchronous calls in the caller" do
-    actor = actor_class.new "James Dean" # is this in bad taste?
-
-    expect do
-      actor.crash
-    end.to raise_exception(ExampleCrash)
-  end
-
-  describe "when #abort is called" do
-    it "raises exceptions in the caller but keeps running" do
-      actor = actor_class.new "Al Pacino"
-
-      e = nil
-      line_no = nil
-
-      expect do
-        begin
-          line_no = __LINE__; actor.crash_with_abort "You die motherfucker!", :bar
-        rescue => ex
-          e = ex
-          raise
-        end
-      end.to raise_exception(ExampleCrash, "You die motherfucker!")
-
-      e.backtrace.any? { |line| line.include?([__FILE__, line_no].join(':')) }.should be_true # Check the backtrace is appropriate to the caller
-      e.foo.should be == :bar # Check the exception maintains instance variables
-
-      actor.should be_alive
-    end
-
-    it "converts strings to runtime errors" do
-      actor = actor_class.new "Al Pacino"
-      expect do
-        actor.crash_with_abort_raw "foo"
-      end.to raise_exception(RuntimeError, "foo")
-    end
-
-    it "crashes the caller if we pass neither String nor Exception" do
-      actor = actor_class.new "Al Pacino"
-      expect do
-        actor.crash_with_abort_raw 10
-      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
-
-      actor.greet rescue nil # Ensure our actor has died.
-      actor.should_not be_alive
-    end
-  end
-
-  it "raises DeadActorError if methods are synchronously called on a dead actor" do
-    actor = actor_class.new "James Dean"
-    actor.crash rescue nil
-
-    expect do
-      actor.greet
-    end.to raise_exception(Celluloid::DeadActorError)
-  end
-
-  it "supports method! syntax for asynchronous calls" do
-    actor = actor_class.new "Troy McClure"
-    actor.change_name! "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+  it "calls the user defined finalizer" do
+    actor = actor_class.new "Mr. Bean"
+    actor.wrapped_object.should_receive(:my_finalizer)
+    actor.terminate
+    Celluloid::Actor.join(actor)
   end
 
   it "supports async(:method) syntax for asynchronous calls" do
@@ -160,19 +112,13 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.greet.should == "Hi, I'm Charlie Sheen"
   end
 
-  it "supports method! syntax for asynchronous calls to itself" do
-    actor = actor_class.new "Troy McClure"
-    actor.change_name_with_a_bang "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
-  end
-
   it "supports async.method syntax for asynchronous calls to itself" do
     actor = actor_class.new "Troy McClure"
     actor.change_name_async "Charlie Sheen"
     actor.greet.should == "Hi, I'm Charlie Sheen"
   end
 
-  it "allows an actor to call private methods asynchronously with a bang" do
+  it "allows an actor to call private methods asynchronously" do
     actor = actor_class.new "Troy McClure"
     actor.call_private
     actor.private_called.should be_true
@@ -188,7 +134,7 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "inspects properly" do
     actor = actor_class.new "Troy McClure"
-    actor.inspect.should match(/Celluloid::Actor\(/)
+    actor.inspect.should match(/Celluloid::ActorProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('@name="Troy McClure"')
     actor.inspect.should_not include("@celluloid")
@@ -215,6 +161,11 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.wrapped_object.inspect.should include Celluloid::BARE_OBJECT_WARNING_MESSAGE
   end
 
+  it "can override #send" do
+    actor = actor_class.new "Troy McClure"
+    actor.send('foo').should == 'oof'
+  end
+
   context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 
@@ -231,6 +182,82 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context :exceptions do
+    it "reraises exceptions which occur during synchronous calls in the caller" do
+      actor = actor_class.new "James Dean" # is this in bad taste?
+
+      expect do
+        actor.crash
+      end.to raise_exception(ExampleCrash)
+    end
+
+    it "includes both caller and receiver in exception traces" do
+      ExampleReceiver = Class.new do
+        include included_module
+
+        def receiver_method
+          raise ExampleCrash, "the spec purposely crashed me :("
+        end
+      end
+
+      ExampleCaller = Class.new do
+        include included_module
+
+        def caller_method
+          ExampleReceiver.new.receiver_method
+        end
+      end
+
+      ex = nil
+      begin
+        ExampleCaller.new.caller_method
+      rescue => ex
+      end
+
+      ex.should be_a ExampleCrash
+      ex.backtrace.grep(/`caller_method'/).should be_true
+      ex.backtrace.grep(/`receiver_method'/).should be_true
+    end
+
+    it "raises DeadActorError if methods are synchronously called on a dead actor" do
+      actor = actor_class.new "James Dean"
+      actor.crash rescue nil
+
+      expect do
+        actor.greet
+      end.to raise_exception(Celluloid::DeadActorError)
+    end
+  end
+
+  context :abort do
+    it "raises exceptions in the caller but keeps running" do
+      actor = actor_class.new "Al Pacino"
+
+      expect do
+        actor.crash_with_abort "You die motherfucker!", :bar
+      end.to raise_exception(ExampleCrash, "You die motherfucker!")
+
+      actor.should be_alive
+    end
+
+    it "converts strings to runtime errors" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw "foo"
+      end.to raise_exception(RuntimeError, "foo")
+    end
+
+    it "crashes the caller if we pass neither String nor Exception" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw 10
+      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
+
+      actor.greet rescue nil # Ensure our actor has died.
+      actor.should_not be_alive
+    end
+  end
+
   context :termination do
     it "terminates" do
       actor = actor_class.new "Arnold Schwarzenegger"
@@ -240,7 +267,7 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.should_not be_alive
     end
 
-    it "kills" do
+    it "kills" do # THOU SHALT ALWAYS KILL
       actor = actor_class.new "Woody Harrelson"
       actor.should be_alive
       Celluloid::Actor.kill(actor)
@@ -270,7 +297,7 @@ shared_context "a Celluloid Actor" do |included_module|
   context :current_actor do
     it "knows the current actor" do
       actor = actor_class.new "Roger Daltrey"
-      actor.current_actor.should == actor
+      actor.current_actor.should eq actor
     end
 
     it "raises NotActorError if called outside an actor" do
@@ -420,7 +447,7 @@ shared_context "a Celluloid Actor" do |included_module|
       obj = @signaler.new
       obj.should_not be_signaled
 
-      obj.wait_for_signal!
+      obj.async.wait_for_signal
       obj.should_not be_signaled
 
       obj.send_signal :foobar
@@ -533,8 +560,8 @@ shared_context "a Celluloid Actor" do |included_module|
 
     it "executes two methods in an exclusive order" do
       actor = subject.new
-      actor.eat_donuts!
-      actor.drink_coffee!
+      actor.async.eat_donuts
+      actor.async.drink_coffee
       sleep Celluloid::TIMER_QUANTUM * 2
       actor.tasks.should == ['donuts', 'coffee']
     end
@@ -574,7 +601,6 @@ shared_context "a Celluloid Actor" do |included_module|
   end
 
   context :timers do
-
     before do
       @klass = Class.new do
         include included_module
@@ -716,33 +742,13 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
-  context :proxy_class do
-    class ExampleProxy < Celluloid::ActorProxy; end
-
-    subject do
-      Class.new do
-        include included_module
-        proxy_class ExampleProxy
-      end
-    end
-
-    it "uses user-specified proxy" do
-      subject.new.__class__.should == ExampleProxy
-    end
-
-    it "retains custom proxy when subclassed" do
-      subclass = Class.new(subject)
-      subclass.new.__class__.should == ExampleProxy
-    end
-  end
-
-  context :use_mailbox do
+  context :mailbox_class do
     class ExampleMailbox < Celluloid::Mailbox; end
 
     subject do
       Class.new do
         include included_module
-        use_mailbox ExampleMailbox
+        mailbox_class ExampleMailbox
       end
     end
 
@@ -756,23 +762,23 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
-  context :mailbox_class do
-    class ExampleMailbox < Celluloid::Mailbox; end
+  context :proxy_class do
+    class ExampleProxy < Celluloid::ActorProxy; end
 
     subject do
       Class.new do
         include included_module
-        mailbox_class ExampleMailbox
+        proxy_class ExampleProxy
       end
     end
 
-    it "overrides the mailbox class" do
-      subject.new.mailbox.should be_a ExampleMailbox
+    it "uses user-specified proxy" do
+      subject.new.__class__.should == ExampleProxy
     end
 
-    it "retains custom mailboxes when subclassed" do
+    it "retains custom proxy when subclassed" do
       subclass = Class.new(subject)
-      subclass.new.mailbox.should be_a ExampleMailbox
+      subclass.new.__class__.should == ExampleProxy
     end
   end