celluloid 0.15.2 → 0.16.0

data/lib/celluloid/probe.rb

@@ -0,0 +1,73 @@
+require 'celluloid'
+
+$CELLULOID_MONITORING = true
+
+module Celluloid
+  class Probe
+    include Celluloid
+    include Celluloid::Notifications
+
+    NOTIFICATIONS_TOPIC_BASE = 'celluloid.events.%s'
+    INITIAL_EVENTS = Queue.new
+
+    class << self
+      def run
+        # spawn the actor if not found
+        supervise_as(:probe_actor) unless Actor[:probe_actor] && Actor[:probe_actor].alive?
+      end
+
+      def actor_created(actor)
+        trigger_event(:actor_created, actor)
+      end
+
+      def actor_named(actor)
+        trigger_event(:actor_named, actor)
+      end
+
+      def actor_died(actor)
+        trigger_event(:actor_died, actor)
+      end
+
+      def actors_linked(a, b)
+        a = find_actor(a)
+        b = find_actor(b)
+        trigger_event(:actors_linked, a, b)
+      end
+
+      private
+
+      def trigger_event(name, *args)
+        return unless $CELLULOID_MONITORING
+        probe_actor = Actor[:probe_actor]
+        if probe_actor
+          probe_actor.async.dispatch_event(name, args)
+        else
+          INITIAL_EVENTS << [name, args]
+        end
+      end
+
+      def find_actor(obj)
+        if obj.__send__(:class) == Actor
+          obj
+        elsif owner = obj.instance_variable_get(OWNER_IVAR)
+          owner
+        end
+      end
+    end
+
+    def initialize
+      async.first_run
+    end
+
+    def first_run
+      until INITIAL_EVENTS.size == 0
+        event = INITIAL_EVENTS.pop
+        dispatch_event(*event)
+      end
+    end
+
+    def dispatch_event(cmd, args)
+      publish(NOTIFICATIONS_TOPIC_BASE % cmd, args)
+    end
+  end
+end

data/lib/celluloid/properties.rb

@@ -9,7 +9,7 @@ module Celluloid
 
       ancestors.first.send(:define_singleton_method, name) do |value = nil, *extra|
         if value
-          value = value ? [value, *extra] : [] if multi
+          value = value ? [value, *send(name), *extra].uniq : [] if multi
           instance_variable_set(ivar_name, value)
         elsif instance_variables.include?(ivar_name)
           instance_variable_get(ivar_name)
@@ -21,4 +21,4 @@ module Celluloid
       end
     end
   end
-end
+end

data/lib/celluloid/proxies/actor_proxy.rb

@@ -1,59 +1,27 @@
 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 < SyncProxy
-    attr_reader :thread
+  # A proxy which controls the Actor lifecycle
+  class ActorProxy < AbstractProxy
+    attr_reader :thread, :mailbox
 
     # Used for reflecting on proxy objects themselves
     def __class__; ActorProxy; end
 
-    def initialize(actor)
-      @thread = actor.thread
-
-      super(actor.mailbox, actor.subject.class.to_s)
-      @sync_proxy   = SyncProxy.new(@mailbox, @klass)
-      @async_proxy  = AsyncProxy.new(@mailbox, @klass)
-      @future_proxy = FutureProxy.new(@mailbox, @klass)
-    end
-
-    def _send_(meth, *args, &block)
-      method_missing :__send__, meth, *args, &block
+    def initialize(thread, mailbox)
+      @thread = thread
+      @mailbox = mailbox
     end
 
     def inspect
-      method_missing :inspect
+      # TODO: use a system event to fetch actor state: tasks?
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) alive>"
     rescue DeadActorError
-      "#<Celluloid::ActorProxy(#{@klass}) dead>"
-    end
-
-    def method(name)
-      Method.new(self, name)
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) dead>"
     end
 
     def alive?
       @mailbox.alive?
     end
 
-    alias_method :sync, :method_missing
-
-    # Obtain an async proxy or explicitly invoke a named async method
-    def async(method_name = nil, *args, &block)
-      if method_name
-        @async_proxy.method_missing method_name, *args, &block
-      else
-        @async_proxy
-      end
-    end
-
-    # Obtain a future proxy or explicitly invoke a named future method
-    def future(method_name = nil, *args, &block)
-      if method_name
-        @future_proxy.method_missing method_name, *args, &block
-      else
-        @future_proxy
-      end
-    end
-
     # Terminate the associated actor
     def terminate
       terminate!

data/lib/celluloid/proxies/cell_proxy.rb

@@ -0,0 +1,68 @@
+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 CellProxy < SyncProxy
+    # Used for reflecting on proxy objects themselves
+    def __class__; CellProxy; end
+
+    def initialize(actor_proxy, mailbox, klass)
+      super(mailbox, klass)
+      @actor_proxy  = actor_proxy
+      @sync_proxy   = SyncProxy.new(mailbox, klass)
+      @async_proxy  = AsyncProxy.new(mailbox, klass)
+      @future_proxy = FutureProxy.new(mailbox, klass)
+    end
+
+    def _send_(meth, *args, &block)
+      method_missing :__send__, meth, *args, &block
+    end
+
+    def inspect
+      method_missing :inspect
+    rescue DeadActorError
+      "#<Celluloid::CellProxy(#{@klass}) dead>"
+    end
+
+    def method(name)
+      Method.new(self, name)
+    end
+
+    alias_method :sync, :method_missing
+
+    # Obtain an async proxy or explicitly invoke a named async method
+    def async(method_name = nil, *args, &block)
+      if method_name
+        @async_proxy.method_missing method_name, *args, &block
+      else
+        @async_proxy
+      end
+    end
+
+    # Obtain a future proxy or explicitly invoke a named future method
+    def future(method_name = nil, *args, &block)
+      if method_name
+        @future_proxy.method_missing method_name, *args, &block
+      else
+        @future_proxy
+      end
+    end
+
+    def alive?
+      @actor_proxy.alive?
+    end
+
+    def thread
+      @actor_proxy.thread
+    end
+
+    # Terminate the associated actor
+    def terminate
+      @actor_proxy.terminate
+    end
+
+    # Terminate the associated actor asynchronously
+    def terminate!
+      @actor_proxy.terminate!
+    end
+  end
+end

data/lib/celluloid/proxies/sync_proxy.rb

@@ -15,7 +15,7 @@ module Celluloid
     end
 
     def respond_to?(meth, include_private = false)
-      __class__.instance_methods.include?(meth) || super
+      __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
     end
 
     def method_missing(meth, *args, &block)

data/lib/celluloid/receivers.rb

@@ -1,12 +1,13 @@
 require 'set'
+
 require 'timers'
 
 module Celluloid
   # Allow methods to directly interact with the actor protocol
   class Receivers
-    def initialize
+    def initialize(timers)
       @receivers = Set.new
-      @timers = Timers.new
+      @timers = timers
     end
 
     # Receive an asynchronous message
@@ -28,24 +29,15 @@ module Celluloid
       end
     end
 
-    # How long to wait until the next timer fires
-    def wait_interval
-      @timers.wait_interval
-    end
-
-    # Fire any pending timers
-    def fire_timers
-      @timers.fire
-    end
-
     # Handle incoming messages
     def handle_message(message)
       receiver = @receivers.find { |r| r.match(message) }
       return unless receiver
 
       @receivers.delete receiver
-      @timers.cancel receiver.timer if receiver.timer
+      receiver.timer.cancel if receiver.timer
       receiver.resume message
+      message
     end
   end
 

data/lib/celluloid/registry.rb

@@ -3,10 +3,6 @@ require 'thread'
 module Celluloid
   # The Registry allows us to refer to specific actors by human-meaningful names
   class Registry
-    class << self
-      attr_reader :root
-    end
-
     def initialize
       @registry = {}
       @registry_lock = Mutex.new
@@ -15,7 +11,7 @@ module Celluloid
     # Register an Actor
     def []=(name, actor)
       actor_singleton = class << actor; self; end
-      unless actor_singleton.ancestors.include? ActorProxy
+      unless actor_singleton.ancestors.include? AbstractProxy
         raise TypeError, "not an actor"
       end
 
@@ -57,8 +53,5 @@ module Celluloid
       end
       hash
     end
-
-    # Create the default registry
-    @root = new
   end
 end

data/{spec/support → lib/celluloid/rspec}/actor_examples.rb

@@ -65,6 +65,19 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     method.arity.should be(1)
   end
 
+  it "supports #name calls via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.name.should == :greet
+  end
+
+  it "supports #parameters via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.parameters.should == []
+
+    method = actor_class.new("Troy McClure").method(:change_name)
+    method.parameters.should == [[:req, :new_name]]
+  end
+
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
@@ -148,7 +161,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       end
     end
 
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:warn).with(/Dangerously suspending task: type=:call, meta={:method_name=>:initialize}, status=:sleeping/)
 
     actor = klass.new
@@ -175,7 +187,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       end
     end
 
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:warn).with(/Dangerously suspending task: type=:finalizer, meta={:method_name=>:cleanup}, status=:sleeping/)
 
     actor = klass.new
@@ -221,7 +232,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
   it "inspects properly" do
     actor = actor_class.new "Troy McClure"
-    actor.inspect.should match(/Celluloid::ActorProxy\(/)
+    actor.inspect.should match(/Celluloid::CellProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('@name="Troy McClure"')
     actor.inspect.should_not include("@celluloid")
@@ -230,7 +241,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   it "inspects properly when dead" do
     actor = actor_class.new "Troy McClure"
     actor.terminate
-    actor.inspect.should match(/Celluloid::ActorProxy\(/)
+    actor.inspect.should match(/Celluloid::CellProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('dead')
   end
@@ -252,7 +263,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     itchy.other = scratchy
 
     inspection = itchy.inspect
-    inspection.should match(/Celluloid::ActorProxy\(/)
+    inspection.should match(/Celluloid::CellProxy\(/)
     inspection.should include("...")
   end
 
@@ -274,6 +285,31 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.send('foo').should eq('oof')
   end
 
+  context "when executing under JRuby" do
+    let(:klass) {
+      Class.new do
+        include included_module
+        task_class task_klass
+
+        def current_thread_name
+          java_thread.get_name
+        end
+
+        def java_thread
+          Thread.current.to_java.getNativeThread
+        end
+      end
+    }
+
+    it "sets execution info" do
+      klass.new.current_thread_name.should == "Class#current_thread_name"
+    end
+
+    it "unsets execution info after task completion" do
+      klass.new.java_thread.get_name.should == "<unused>"
+    end
+  end if RUBY_PLATFORM == "java"
+
   context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 
@@ -300,27 +336,27 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     end
 
     it "includes both sender and receiver in exception traces" do
-      ExampleReceiver = Class.new do
+      example_receiver = Class.new do
         include included_module
         task_class task_klass
 
-        def receiver_method
+        define_method(:receiver_method) do
           raise ExampleCrash, "the spec purposely crashed me :("
         end
       end
 
-      ExampleCaller = Class.new do
+      excample_caller = Class.new do
         include included_module
         task_class task_klass
 
-        def sender_method
-          ExampleReceiver.new.receiver_method
+        define_method(:sender_method) do
+          example_receiver.new.receiver_method
         end
       end
 
       ex = nil
       begin
-        ExampleCaller.new.sender_method
+        excample_caller.new.sender_method
       rescue => ex
       end
 
@@ -404,6 +440,15 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       end.to raise_exception(Celluloid::DeadActorError)
     end
 
+    it "terminates cleanly on Celluloid shutdown" do
+      Celluloid::Actor.stub(:kill).and_call_original
+
+      actor = actor_class.new "Arnold Schwarzenegger"
+
+      Celluloid.shutdown
+      Celluloid::Actor.should_not have_received(:kill)
+    end
+
     it "raises the right DeadActorError if terminate! called after terminated" do
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.terminate
@@ -414,8 +459,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     end
 
     it "logs a warning when terminating tasks" do
-      Celluloid.logger = double.as_null_object
-      Celluloid.logger.should_receive(:warn).with("Terminating task: type=:call, meta={:method_name=>:sleepy}, status=:sleeping")
+      Celluloid.logger.should_receive(:warn).with(/^Terminating task: type=:call, meta={:method_name=>:sleepy}, status=:sleeping\n/)
 
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.async.sleepy 10
@@ -923,7 +967,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   end
 
   context :proxy_class do
-    class ExampleProxy < Celluloid::ActorProxy
+    class ExampleProxy < Celluloid::CellProxy
       def subclass_proxy?
         true
       end
@@ -1000,7 +1044,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
   context "raw message sends" do
     it "logs on unhandled messages" do
-      Celluloid.logger = double.as_null_object
       Celluloid.logger.should_receive(:debug).with("Discarded message (unhandled): first")
 
       actor = actor_class.new "Irma Gladden"

data/{spec/support → lib/celluloid/rspec}/mailbox_examples.rb

@@ -1,4 +1,9 @@
 shared_context "a Celluloid Mailbox" do
+  after do
+    Celluloid.logger.stub(:debug)
+    subject.shutdown if subject.alive?
+  end
+
   it "receives messages" do
     message = :ohai
 
@@ -34,7 +39,10 @@ shared_context "a Celluloid Mailbox" do
     interval = 0.1
     started_at = Time.now
 
-    subject.receive(interval) { false }
+    expect do
+      subject.receive(interval) { false }
+    end.to raise_exception(Celluloid::TimeoutError)
+
     (Time.now - started_at).should be_within(Celluloid::TIMER_QUANTUM).of interval
   end
 
@@ -55,7 +63,6 @@ shared_context "a Celluloid Mailbox" do
   end
 
   it "logs discarded messages" do
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
 
     subject.max_size = 2
@@ -65,7 +72,6 @@ shared_context "a Celluloid Mailbox" do
   end
 
   it "discard messages when dead" do
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): first")
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): second")
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")

data/{spec/support → lib/celluloid/rspec}/task_examples.rb

@@ -17,11 +17,13 @@ shared_context "a Celluloid Task" do |task_class|
   subject { task_class.new(task_type, {}) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
+    Thread.current[:celluloid_actor_system] = Celluloid.actor_system
     Thread.current[:celluloid_actor] = actor
   end
 
   after :each do
     Thread.current[:celluloid_actor] = nil
+    Thread.current[:celluloid_actor_system] = nil
   end
 
   it "begins with status :new" do

data/lib/celluloid/rspec.rb

@@ -1,6 +1,7 @@
-require File.expand_path('../../../spec/support/example_actor_class', __FILE__)
-require File.expand_path('../../../spec/support/actor_examples', __FILE__)
-require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)
+require 'celluloid/rspec/example_actor_class'
+require 'celluloid/rspec/actor_examples'
+require 'celluloid/rspec/mailbox_examples'
+require 'celluloid/rspec/task_examples'
 
 module Celluloid
   # Timer accuracy enforced by the tests (50ms)

data/lib/celluloid/stack_dump.rb

@@ -16,17 +16,21 @@ module Celluloid
 
     class ActorState
       include DisplayBacktrace
-
-      attr_accessor :subject_id, :subject_class, :name
+      attr_accessor :name, :id, :cell
       attr_accessor :status, :tasks
       attr_accessor :backtrace
 
       def dump
         string = ""
-        string << "Celluloid::Actor 0x#{subject_id.to_s(16)}: #{subject_class}"
+        string << "Celluloid::Actor 0x#{id.to_s(16)}"
         string << " [#{name}]" if name
         string << "\n"
 
+        if cell
+          string << cell.dump
+          string << "\n"
+        end
+
         if status == :idle
           string << "State: Idle (waiting for messages)\n"
           display_backtrace backtrace, string
@@ -46,12 +50,18 @@ module Celluloid
       end
     end
 
-    class ThreadState < Struct.new(:thread_id, :backtrace)
+    class CellState < Struct.new(:subject_id, :subject_class)
+      def dump
+        "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
+      end
+    end
+
+    class ThreadState < Struct.new(:thread_id, :backtrace, :role)
       include DisplayBacktrace
 
       def dump
         string = ""
-        string << "Thread 0x#{thread_id.to_s(16)}:\n"
+        string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
         display_backtrace backtrace, string
         string
       end
@@ -59,7 +69,9 @@ module Celluloid
 
     attr_accessor :actors, :threads
 
-    def initialize
+    def initialize(internal_pool)
+      @internal_pool = internal_pool
+
       @actors  = []
       @threads = []
 
@@ -67,7 +79,7 @@ module Celluloid
     end
 
     def snapshot
-      Celluloid.internal_pool.each do |thread|
+      @internal_pool.each do |thread|
         if thread.role == :actor
           @actors << snapshot_actor(thread.actor) if thread.actor
         else
@@ -78,8 +90,12 @@ module Celluloid
 
     def snapshot_actor(actor)
       state = ActorState.new
-      state.subject_id = actor.subject.object_id
-      state.subject_class = actor.subject.class
+      state.id = actor.object_id
+
+      # TODO: delegate to the behavior
+      if actor.behavior.is_a?(Cell)
+        state.cell = snapshot_cell(actor.behavior)
+      end
 
       tasks = actor.tasks
       if tasks.empty?
@@ -93,11 +109,18 @@ module Celluloid
       state
     end
 
+    def snapshot_cell(behavior)
+      state = CellState.new
+      state.subject_id = behavior.subject.object_id
+      state.subject_class = behavior.subject.class
+      state
+    end
+
     def snapshot_thread(thread)
-      ThreadState.new(thread.object_id, thread.backtrace)
+      ThreadState.new(thread.object_id, thread.backtrace, thread.role)
     end
 
-    def dump(output = STDERR)
+    def print(output = STDERR)
       @actors.each do |actor|
         output.print actor.dump
       end